zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of ssh://dm/home/dm4/OpenFOAM/repositories/OpenFOAM-dev

Browse Source
This commit is contained in:
Henry
2013-12-13 15:36:29 +00:00
parent 541a03f773 171d004cb4
commit 1b06c634ce
56 changed files with 2045 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
applications/utilities/mesh/manipulation/createBaffles/createBaffles.C
View File

@ -83,6 +83,7 @@ label addPatch
pp.inGroups().append(groupName);
}
// Add patch, create calculated everywhere
fvMeshTools::addPatch
(
@ -636,18 +637,17 @@ int main(int argc, char *argv[])
// Note: This is added for the particular case where we want
// master and slave in different groupNames
// (ie 3D thermal baffles)
bool groupBase = false;
if (patchSource.found("groupBase"))
{
groupBase = readBool(patchSource.lookup("groupBase"));
if (groupBase)
{
groupNameMaster = groupName + "Group_master";
groupNameSlave = groupName + "Group_slave";
patchDictMaster.set("coupleGroup", groupNameMaster);
patchDictSlave.set("coupleGroup", groupNameSlave);
}
Switch sameGroup
(
patchSource.lookupOrDefault("sameGroup", true)
);
if (!sameGroup)
{
groupNameMaster = groupName + "Group_master";
groupNameSlave = groupName + "Group_slave";
patchDictMaster.set("coupleGroup", groupNameMaster);
patchDictSlave.set("coupleGroup", groupNameSlave);
}
addPatch(mesh, masterName, groupNameMaster, patchDictMaster);
@ -818,11 +818,11 @@ int main(int argc, char *argv[])
else
{
const dictionary& patchSource = dict.subDict("patchPairs");
bool groupBase = false;
if (patchSource.found("groupBase"))
{
groupBase = readBool(patchSource.lookup("groupBase"));
}
Switch sameGroup
(
patchSource.lookupOrDefault("sameGroup", true)
);
const word& groupName = selectors[selectorI].name();
@ -833,7 +833,7 @@ int main(int argc, char *argv[])
"patchFields"
);
if (!groupBase)
if (sameGroup)
{
// Add coupleGroup to all entries
forAllIter(dictionary, patchFieldsDict, iter)

2
applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C
View File

@ -1078,7 +1078,6 @@ labelList addRegionPatches
mesh.boundaryMesh()
);
//interfacePatches[interI] = addPatch(mesh, patch1);
interfacePatches[interI] = fvMeshTools::addPatch
(
mesh,
@ -1100,7 +1099,6 @@ labelList addRegionPatches
point::zero, // offset
mesh.boundaryMesh()
);
//addPatch(mesh, patch2);
fvMeshTools::addPatch
(
mesh,

18
src/OpenFOAM/meshes/polyMesh/polyPatches/derived/wall/wallPolyPatch.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -49,7 +49,13 @@ Foam::wallPolyPatch::wallPolyPatch
)
:
polyPatch(name, size, start, index, bm, patchType)
{}
{
// wall is not constraint type so add wall group explicitly
if (findIndex(inGroups(), typeName) == -1)
{
inGroups().append(typeName);
}
}
Foam::wallPolyPatch::wallPolyPatch
@ -62,7 +68,13 @@ Foam::wallPolyPatch::wallPolyPatch
)
:
polyPatch(name, dict, index, bm, patchType)
{}
{
// wall is not constraint type so add wall group explicitly
if (findIndex(inGroups(), typeName) == -1)
{
inGroups().append(typeName);
}
}
Foam::wallPolyPatch::wallPolyPatch

2
src/finiteVolume/Make/files
View File

@ -251,6 +251,8 @@ surfaceInterpolation = interpolation/surfaceInterpolation
$(surfaceInterpolation)/surfaceInterpolation/surfaceInterpolation.C
$(surfaceInterpolation)/surfaceInterpolationScheme/surfaceInterpolationSchemes.C
$(surfaceInterpolation)/blendedSchemeBase/blendedSchemeBaseName.C
schemes = $(surfaceInterpolation)/schemes
$(schemes)/linear/linear.C
$(schemes)/pointLinear/pointLinear.C

5
src/finiteVolume/fields/fvPatchFields/derived/flowRateInletVelocity/flowRateInletVelocityFvPatchVectorField.C
View File

@ -199,10 +199,7 @@ void Foam::flowRateInletVelocityFvPatchVectorField::updateCoeffs()
else
{
// mass flow-rate
if
(
patch().boundaryMesh().mesh().foundObject<volScalarField>(rhoName_)
)
if (db().foundObject<volScalarField>(rhoName_))
{
const fvPatchField<scalar>& rhop =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);

10
src/finiteVolume/finiteVolume/convectionSchemes/gaussConvectionScheme/gaussConvectionScheme.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -39,6 +39,14 @@ namespace fv
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type>
const surfaceInterpolationScheme<Type>&
gaussConvectionScheme<Type>::interpScheme() const
{
return tinterpScheme_();
}
template<class Type>
tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
gaussConvectionScheme<Type>::interpolate

4
src/finiteVolume/finiteVolume/convectionSchemes/gaussConvectionScheme/gaussConvectionScheme.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -134,6 +134,8 @@ public:
// Member Functions
const surfaceInterpolationScheme<Type>& interpScheme() const;
tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > interpolate
(
const surfaceScalarField&,

118
src/finiteVolume/finiteVolume/fvc/fvcCellReduce.C Normal file
View File

@ -0,0 +1,118 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "fvcCellReduce.H"
#include "fvMesh.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "zeroGradientFvPatchFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace fvc
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type, class CombineOp>
tmp<GeometricField<Type, fvPatchField, volMesh> > cellReduce
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& ssf,
const CombineOp& cop
)
{
typedef GeometricField<Type, fvPatchField, volMesh> volFieldType;
const fvMesh& mesh = ssf.mesh();
tmp<volFieldType> tresult
(
new volFieldType
(
IOobject
(
"cellReduce(" + ssf.name() + ')',
ssf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensioned<Type>("0", ssf.dimensions(), pTraits<Type>::zero),
zeroGradientFvPatchField<Type>::typeName
)
);
volFieldType& result = tresult();
const labelUList& own = mesh.owner();
const labelUList& nbr = mesh.neighbour();
forAll(own, i)
{
label cellI = own[i];
cop(result[cellI], ssf[i]);
}
forAll(nbr, i)
{
label cellI = nbr[i];
cop(result[cellI], ssf[i]);
}
result.correctBoundaryConditions();
return tresult;
}
template<class Type, class CombineOp>
tmp<GeometricField<Type, fvPatchField, volMesh> > cellReduce
(
const tmp<GeometricField<Type, fvsPatchField, surfaceMesh>&> tssf,
const CombineOp& cop
)
{
tmp<GeometricField<Type, fvPatchField, volMesh> >
tvf(cellReduce(cop, tssf));
tssf.clear();
return tvf;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace fvc
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

82
src/finiteVolume/finiteVolume/fvc/fvcCellReduce.H Normal file
View File

@ -0,0 +1,82 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
InNamespace
Foam::fvc
Description
Construct a volume field from a surface field using a combine operator.
SourceFiles
fvcCellReduce.C
\*---------------------------------------------------------------------------*/
#ifndef fvcCellReduce_H
#define fvcCellReduce_H
#include "volFieldsFwd.H"
#include "surfaceFieldsFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Namespace fvc functions Declaration
\*---------------------------------------------------------------------------*/
namespace fvc
{
template<class Type, class CombineOp>
tmp<GeometricField<Type, fvPatchField, volMesh> > cellReduce
(
const GeometricField<Type, fvsPatchField, surfaceMesh>&,
const CombineOp& cop
);
template<class Type, class CombineOp>
tmp<GeometricField<Type, fvPatchField, volMesh> > cellReduce
(
const tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >&,
const CombineOp& cop
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "fvcCellReduce.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

87
src/finiteVolume/interpolation/surfaceInterpolation/blendedSchemeBase/blendedSchemeBase.H Normal file
View File

@ -0,0 +1,87 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
Class
Foam::blendedSchemeBase
Description
Base class for blended schemes to provide access to the blending factor
surface field
\*---------------------------------------------------------------------------*/
#ifndef blendedSchemeBase_H
#define blendedSchemeBase_H
#include "className.H"
#include "tmp.H"
#include "surfaceFieldsFwd.H"
#include "volFieldsFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
TemplateName(blendedSchemeBase);
/*---------------------------------------------------------------------------*\
Class blendedSchemeBase Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class blendedSchemeBase
:
public blendedSchemeBaseName
{
public:
//- Constructor
blendedSchemeBase()
{}
//- Destructor
virtual ~blendedSchemeBase()
{}
// Memeber Functions
//- Return the face-based blending factor
virtual tmp<surfaceScalarField> blendingFactor
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

36
src/finiteVolume/interpolation/surfaceInterpolation/blendedSchemeBase/blendedSchemeBaseName.C Normal file
View File

@ -0,0 +1,36 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "blendedSchemeBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(blendedSchemeBaseName, 0);
}
// ************************************************************************* //

38
src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/blended/blended.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,6 +36,7 @@ SourceFiles
#define blended_H
#include "limitedSurfaceInterpolationScheme.H"
#include "blendedSchemeBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -49,7 +50,8 @@ namespace Foam
template<class Type>
class blended
:
public limitedSurfaceInterpolationScheme<Type>
public limitedSurfaceInterpolationScheme<Type>,
public blendedSchemeBase<Type>
{
// Private data
@ -111,8 +113,40 @@ public:
{}
//- Destructor
virtual ~blended()
{}
// Member Functions
//- Return the face-based blending factor
virtual tmp<surfaceScalarField> blendingFactor
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
return tmp<surfaceScalarField>
(
new surfaceScalarField
(
IOobject
(
vf.name() + "BlendingFactor",
this->mesh().time().timeName(),
this->mesh()
),
this->mesh(),
dimensionedScalar
(
"blendingFactor",
dimless,
blendingFactor_
)
)
);
}
//- Return the interpolation limiter
virtual tmp<surfaceScalarField> limiter
(

59
src/finiteVolume/interpolation/surfaceInterpolation/schemes/CoBlended/CoBlended.H
View File

@ -63,6 +63,7 @@ SourceFiles
#define CoBlended_H
#include "surfaceInterpolationScheme.H"
#include "blendedSchemeBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -76,7 +77,8 @@ namespace Foam
template<class Type>
class CoBlended
:
public surfaceInterpolationScheme<Type>
public surfaceInterpolationScheme<Type>,
public blendedSchemeBase<Type>
{
// Private data
@ -135,10 +137,7 @@ public:
),
faceFlux_
(
mesh.lookupObject<surfaceScalarField>
(
word(is)
)
mesh.lookupObject<surfaceScalarField>(word(is))
)
{
if (Co1_ < 0 || Co2_ < 0 || Co1_ >= Co2_)
@ -170,7 +169,7 @@ public:
(
surfaceInterpolationScheme<Type>::New(mesh, faceFlux, is)
),
faceFlux_(faceFlux)
faceFlux_(faceFlux)
{
if (Co1_ < 0 || Co2_ < 0 || Co1_ >= Co2_)
{
@ -182,17 +181,39 @@ public:
}
//- Destructor
virtual ~CoBlended()
{}
// Member Functions
//- Return the face-based Courant number blending factor
tmp<surfaceScalarField> blendingFactor() const
//- Return the face-based blending factor
virtual tmp<surfaceScalarField> blendingFactor
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
const fvMesh& mesh = faceFlux_.mesh();
const fvMesh& mesh = this->mesh();
return
tmp<surfaceScalarField> tbf
(
scalar(1) -
max
new surfaceScalarField
(
IOobject
(
vf.name() + "BlendingFactor",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedScalar("blendingFactor", dimless, 0.0)
)
);
tbf() =
scalar(1)
- max
(
min
(
@ -204,8 +225,9 @@ public:
scalar(1)
),
scalar(0)
)
);
);
return tbf;
}
@ -216,9 +238,10 @@ public:
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
surfaceScalarField bf(blendingFactor());
surfaceScalarField bf(blendingFactor(vf));
Info<< "weights " << max(bf) << " " << min(bf) << endl;
Info<< "weights " << max(bf).value() << " " << min(bf).value()
<< endl;
return
bf*tScheme1_().weights(vf)
@ -234,7 +257,7 @@ public:
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
surfaceScalarField bf(blendingFactor());
surfaceScalarField bf(blendingFactor(vf));
return
bf*tScheme1_().interpolate(vf)
@ -257,7 +280,7 @@ public:
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
surfaceScalarField bf(blendingFactor());
surfaceScalarField bf(blendingFactor(vf));
if (tScheme1_().corrected())
{

33
src/finiteVolume/interpolation/surfaceInterpolation/schemes/localBlended/localBlended.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,6 +36,7 @@ SourceFiles
#define localBlended_H
#include "surfaceInterpolationScheme.H"
#include "blendedSchemeBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -49,7 +50,8 @@ namespace Foam
template<class Type>
class localBlended
:
public surfaceInterpolationScheme<Type>
public surfaceInterpolationScheme<Type>,
public blendedSchemeBase<Type>
{
// Private Member Functions
@ -115,8 +117,27 @@ public:
{}
//- Destructor
virtual ~localBlended()
{}
// Member Functions
//- Return the face-based blending factor
virtual tmp<surfaceScalarField> blendingFactor
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
return
this->mesh().objectRegistry::template
lookupObject<const surfaceScalarField>
(
word(vf.name() + "BlendingFactor")
);
}
//- Return the interpolation weighting factors
tmp<surfaceScalarField> weights
(
@ -125,10 +146,10 @@ public:
{
const surfaceScalarField& blendingFactor =
this->mesh().objectRegistry::template
lookupObject<const surfaceScalarField>
(
word(vf.name() + "BlendingFactor")
);
lookupObject<const surfaceScalarField>
(
word(vf.name() + "BlendingFactor")
);
return
blendingFactor*tScheme1_().weights(vf)

28
src/fvMotionSolver/fvMotionSolvers/displacement/laplacian/displacementLaplacianFvMotionSolver.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -139,6 +139,21 @@ Foam::displacementLaplacianFvMotionSolver::
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::motionDiffusivity&
Foam::displacementLaplacianFvMotionSolver::diffusivity()
{
if (!diffusivityPtr_.valid())
{
diffusivityPtr_ = motionDiffusivity::New
(
fvMesh_,
coeffDict().lookup("diffusivity")
);
}
return diffusivityPtr_();
}
Foam::tmp<Foam::pointField>
Foam::displacementLaplacianFvMotionSolver::curPoints() const
{
@ -210,14 +225,14 @@ void Foam::displacementLaplacianFvMotionSolver::solve()
// the motionSolver accordingly
movePoints(fvMesh_.points());
diffusivityPtr_->correct();
diffusivity().correct();
pointDisplacement_.boundaryField().updateCoeffs();
Foam::solve
(
fvm::laplacian
(
diffusivityPtr_->operator()(),
diffusivity().operator()(),
cellDisplacement_,
"laplacian(diffusivity,cellDisplacement)"
)
@ -234,12 +249,7 @@ void Foam::displacementLaplacianFvMotionSolver::updateMesh
// Update diffusivity. Note two stage to make sure old one is de-registered
// before creating/registering new one.
diffusivityPtr_.reset(NULL);
diffusivityPtr_ = motionDiffusivity::New
(
fvMesh_,
coeffDict().lookup("diffusivity")
);
diffusivityPtr_.clear();
}

6
src/fvMotionSolver/fvMotionSolvers/displacement/laplacian/displacementLaplacianFvMotionSolver.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -53,7 +53,6 @@ class motionDiffusivity;
class displacementLaplacianFvMotionSolver
:
// public displacementFvMotionSolver
public displacementMotionSolver,
public fvMotionSolverCore
{
@ -120,6 +119,9 @@ public:
return cellDisplacement_;
}
//- Return reference to the diffusivity field
motionDiffusivity& diffusivity();
//- Return point location obtained from the current motion field
virtual tmp<pointField> curPoints() const;

2
src/fvOptions/fvOptions/fvIOoptionList.C
View File

@ -45,7 +45,7 @@ Foam::IOobject Foam::fv::IOoptionList::createIOobject
if (io.headerOk())
{
Info<< "Creating fintite volume options from " << io.name() << nl
Info<< "Creating finite volume options from " << io.name() << nl
<< endl;
io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;

1
src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.C
View File

@ -26,7 +26,6 @@ License
#include "SurfaceFilmModel.H"
#include "surfaceFilmModel.H"
#include "mathematicalConstants.H"
#include "mappedPatchBase.H"
using namespace Foam::constant;

2
src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.H
View File

@ -55,8 +55,6 @@ namespace regionModels
}
}
class mappedPatchBase;
/*---------------------------------------------------------------------------*\
Class SurfaceFilmModel Declaration
\*---------------------------------------------------------------------------*/

137
src/mesh/autoMesh/autoHexMesh/externalDisplacementMeshMover/medialAxisMeshMover.C
View File

@ -66,7 +66,6 @@ Foam::labelList Foam::medialAxisMeshMover::getFixedValueBCs
if (isA<valuePointPatchField<vector> >(patchFld))
{
adaptPatchIDs.append(patchI);
//Info<< "Detected adapt patch " << patchFld.patch().name() << endl;
}
}
return adaptPatchIDs;
@ -1259,6 +1258,7 @@ handleFeatureAngleLayerTerminations
void Foam::medialAxisMeshMover::findIsolatedRegions
(
const scalar minCosLayerTermination,
const bool detectExtrusionIsland,
const PackedBoolList& isMasterPoint,
const PackedBoolList& isMasterEdge,
const labelList& meshEdges,
@ -1268,6 +1268,8 @@ void Foam::medialAxisMeshMover::findIsolatedRegions
) const
{
const indirectPrimitivePatch& pp = adaptPatchPtr_();
const labelListList& pointFaces = pp.pointFaces();
Info<< typeName << " : Removing isolated regions ..." << endl;
@ -1292,40 +1294,110 @@ void Foam::medialAxisMeshMover::findIsolatedRegions
syncPatchDisplacement(minThickness, patchDisp, extrudeStatus);
// Do not extrude from point where all neighbouring
// faces are not grown
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
boolList extrudedFaces(pp.size(), true);
forAll(pp.localFaces(), faceI)
{
const face& f = pp.localFaces()[faceI];
forAll(f, fp)
{
if (extrudeStatus[f[fp]] == autoLayerDriver::NOEXTRUDE)
{
extrudedFaces[faceI] = false;
break;
}
}
}
const labelListList& pointFaces = pp.pointFaces();
// Detect either:
// - point where all surrounding points are not extruded
// (detectExtrusionIsland)
// or
// - point where all the faces surrounding it are not fully
// extruded
boolList keptPoints(pp.nPoints(), false);
forAll(keptPoints, patchPointI)
{
const labelList& pFaces = pointFaces[patchPointI];
forAll(pFaces, i)
if (detectExtrusionIsland)
{
// Do not extrude from point where all neighbouring
// points are not grown
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
labelList islandPoint(pp.size(), -1);
forAll(pp, faceI)
{
label faceI = pFaces[i];
if (extrudedFaces[faceI])
const face& f = pp.localFaces()[faceI];
forAll(f, fp)
{
keptPoints[patchPointI] = true;
break;
label patchPointI = f[fp];
if (extrudeStatus[f[fp]] != autoLayerDriver::NOEXTRUDE)
{
if (islandPoint[faceI] == -1)
{
// First point to extrude
islandPoint[faceI] = patchPointI;
}
else
{
// Second or more point to extrude
islandPoint[faceI] = -2;
}
}
}
}
// islandPoint:
// -1 : no point extruded
// -2 : >= 2 points extruded
// >=0: label of point extruded
// Check all surrounding faces that I am the islandPoint
boolList keptPoints(pp.nPoints(), false);
forAll(pointFaces, patchPointI)
{
if (extrudeStatus[patchPointI] != autoLayerDriver::NOEXTRUDE)
{
const labelList& pFaces = pointFaces[patchPointI];
forAll(pFaces, i)
{
label faceI = pFaces[i];
if (islandPoint[faceI] != patchPointI)
{
keptPoints[patchPointI] = true;
break;
}
}
}
}
}
else
{
// Do not extrude from point where all neighbouring
// faces are not grown
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
boolList extrudedFaces(pp.size(), true);
forAll(pp.localFaces(), faceI)
{
const face& f = pp.localFaces()[faceI];
forAll(f, fp)
{
if (extrudeStatus[f[fp]] == autoLayerDriver::NOEXTRUDE)
{
extrudedFaces[faceI] = false;
break;
}
}
}
const labelListList& pointFaces = pp.pointFaces();
forAll(keptPoints, patchPointI)
{
const labelList& pFaces = pointFaces[patchPointI];
forAll(pFaces, i)
{
label faceI = pFaces[i];
if (extrudedFaces[faceI])
{
keptPoints[patchPointI] = true;
break;
}
}
}
}
syncTools::syncPointList
(
@ -1344,8 +1416,8 @@ void Foam::medialAxisMeshMover::findIsolatedRegions
{
if (unmarkExtrusion(patchPointI, patchDisp, extrudeStatus))
{
nPointCounter++;
nChanged++;
nPointCounter++;
nChanged++;
}
}
}
@ -1701,6 +1773,13 @@ void Foam::medialAxisMeshMover::calculateDisplacement
mesh().globalData().nTotalPoints()
);
//- Use strick extrusionIsland detection
const Switch detectExtrusionIsland = coeffDict.lookupOrDefault<label>
(
"detectExtrusionIsland",
true
);
// Precalulate master points/edge (only relevant for shared points/edges)
const PackedBoolList isMasterPoint(syncTools::getMasterPoints(mesh()));
@ -1851,6 +1930,8 @@ void Foam::medialAxisMeshMover::calculateDisplacement
findIsolatedRegions
(
minCosLayerTermination,
detectExtrusionIsland,
isMasterPoint,
isMasterEdge,
meshEdges,

1
src/mesh/autoMesh/autoHexMesh/externalDisplacementMeshMover/medialAxisMeshMover.H
View File

@ -219,6 +219,7 @@ class medialAxisMeshMover
void findIsolatedRegions
(
const scalar minCosLayerTermination,
const bool detectExtrusionIsland,
const PackedBoolList& isMasterPoint,
const PackedBoolList& isMasterEdge,
const labelList& meshEdges,

4
src/mesh/autoMesh/autoHexMesh/refinementFeatures/refinementFeatures.C
View File

@ -303,7 +303,7 @@ Foam::refinementFeatures::refinementFeatures
Info<< "Detected " << featurePoints.size()
<< " featurePoints out of " << pointEdges.size()
<< " on feature " << eMesh.name() << endl;
<< " points on feature " << eMesh.name() << endl;
buildTrees(i, featurePoints);
}
@ -372,7 +372,7 @@ Foam::refinementFeatures::refinementFeatures
Info<< "Detected " << featurePoints.size()
<< " featurePoints out of " << points.size()
<< " on feature " << eMesh.name()
<< " points on feature " << eMesh.name()
<< " when using feature cos " << minCos << endl;
buildTrees(i, featurePoints);

18
src/meshTools/mappedPatches/mappedPolyPatch/mappedPolyPatch.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -51,7 +51,13 @@ Foam::mappedPolyPatch::mappedPolyPatch
:
polyPatch(name, size, start, index, bm, patchType),
mappedPatchBase(static_cast<const polyPatch&>(*this))
{}
{
// mapped is not constraint type so add mapped group explicitly
if (findIndex(inGroups(), typeName) == -1)
{
inGroups().append(typeName);
}
}
Foam::mappedPolyPatch::mappedPolyPatch
@ -115,7 +121,13 @@ Foam::mappedPolyPatch::mappedPolyPatch
:
polyPatch(name, dict, index, bm, patchType),
mappedPatchBase(*this, dict)
{}
{
// mapped is not constraint type so add mapped group explicitly
if (findIndex(inGroups(), typeName) == -1)
{
inGroups().append(typeName);
}
}
Foam::mappedPolyPatch::mappedPolyPatch

19
src/meshTools/mappedPatches/mappedPolyPatch/mappedWallPolyPatch.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,7 @@ License
#include "mappedWallPolyPatch.H"
#include "addToRunTimeSelectionTable.H"
#include "mappedPolyPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -56,7 +57,13 @@ Foam::mappedWallPolyPatch::mappedWallPolyPatch
:
wallPolyPatch(name, size, start, index, bm, patchType),
mappedPatchBase(static_cast<const polyPatch&>(*this))
{}
{
// mapped is not constraint type so add mapped group explicitly
if (findIndex(inGroups(), mappedPolyPatch::typeName) == -1)
{
inGroups().append(mappedPolyPatch::typeName);
}
}
Foam::mappedWallPolyPatch::mappedWallPolyPatch
@ -120,7 +127,13 @@ Foam::mappedWallPolyPatch::mappedWallPolyPatch
:
wallPolyPatch(name, dict, index, bm, patchType),
mappedPatchBase(*this, dict)
{}
{
// mapped is not constraint type so add mapped group explicitly
if (findIndex(inGroups(), mappedPolyPatch::typeName) == -1)
{
inGroups().append(mappedPolyPatch::typeName);
}
}
Foam::mappedWallPolyPatch::mappedWallPolyPatch

3
src/postProcessing/functionObjects/utilities/Make/files
View File

@ -12,6 +12,9 @@ Peclet/PecletFunctionObject.C
Q/Q.C
Q/QFunctionObject.C
blendingFactor/blendingFactor.C
blendingFactor/blendingFactorFunctionObject.C
DESModelRegions/DESModelRegions.C
DESModelRegions/DESModelRegionsFunctionObject.C

4
src/postProcessing/functionObjects/utilities/Peclet/Peclet.C
View File

@ -197,12 +197,12 @@ void Foam::Peclet::execute()
void Foam::Peclet::end()
{
// Do nothing - only valid on write
// Do nothing
}
void Foam::Peclet::timeSet()
{
// Do nothing - only valid on write
// Do nothing
}

49
src/postProcessing/functionObjects/utilities/blendingFactor/IOblendingFactor.H Normal file
View File

@ -0,0 +1,49 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
Typedef
Foam::IOblendingFactor
Description
Instance of the generic IOOutputFilter for blendingFactor.
\*---------------------------------------------------------------------------*/
#ifndef IOblendingFactor_H
#define IOblendingFactor_H
#include "blendingFactor.H"
#include "IOOutputFilter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef IOOutputFilter<blendingFactor> IOblendingFactor;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

131
src/postProcessing/functionObjects/utilities/blendingFactor/blendingFactor.C Normal file
View File

@ -0,0 +1,131 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "blendingFactor.H"
#include "dictionary.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(blendingFactor, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::blendingFactor::blendingFactor
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFiles
)
:
name_(name),
obr_(obr),
active_(true),
phiName_("unknown-phiName"),
fieldName_("unknown-fieldName")
{
// Check if the available mesh is an fvMesh, otherwise deactivate
if (!isA<fvMesh>(obr_))
{
active_ = false;
WarningIn
(
"blendingFactor::blendingFactor"
"("
"const word&, "
"const objectRegistry&, "
"const dictionary&, "
"const bool"
")"
) << "No fvMesh available, deactivating " << name_ << nl
<< endl;
}
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::blendingFactor::~blendingFactor()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::blendingFactor::read(const dictionary& dict)
{
if (active_)
{
phiName_ = dict.lookupOrDefault<word>("phiName", "phi");
dict.lookup("fieldName") >> fieldName_;
}
}
void Foam::blendingFactor::execute()
{
if (active_)
{
calc<scalar>();
calc<vector>();
}
}
void Foam::blendingFactor::end()
{
// Do nothing
}
void Foam::blendingFactor::timeSet()
{
// Do nothing
}
void Foam::blendingFactor::write()
{
if (active_)
{
const word fieldName = "blendingFactor:" + fieldName_;
const volScalarField& blendingFactor =
obr_.lookupObject<volScalarField>(fieldName);
Info<< type() << " " << name_ << " output:" << nl
<< " writing field " << blendingFactor.name() << nl
<< endl;
blendingFactor.write();
}
}
// ************************************************************************* //

175
src/postProcessing/functionObjects/utilities/blendingFactor/blendingFactor.H Normal file
View File

@ -0,0 +1,175 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
Class
Foam::blendingFactor
Group
grpUtilitiesFunctionObjects
Description
This function object calculates and outputs the blendingFactor as used by
the bended convection schemes. The output is a volume field (cells) whose
value is calculated via the maximum blending factor for any cell face.
SourceFiles
blendingFactor.C
IOblendingFactor.H
\*---------------------------------------------------------------------------*/
#ifndef blendingFactor_H
#define blendingFactor_H
#include "volFieldsFwd.H"
#include "surfaceFieldsFwd.H"
#include "OFstream.H"
#include "Switch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class objectRegistry;
class dictionary;
class polyMesh;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class blendingFactor Declaration
\*---------------------------------------------------------------------------*/
class blendingFactor
{
// Private data
//- Name of this set of blendingFactor objects
word name_;
//- Reference to the database
const objectRegistry& obr_;
//- On/off switch
bool active_;
//- Name of flux field, default is "phi"
word phiName_;
//- Field name
word fieldName_;
// Private Member Functions
//- Disallow default bitwise copy construct
blendingFactor(const blendingFactor&);
//- Disallow default bitwise assignment
void operator=(const blendingFactor&);
//- Return the blending factor field from the database
template<class Type>
volScalarField& factor
(
const GeometricField<Type, fvPatchField, volMesh>& field
);
//- Calculate the blending factor
template<class Type>
void calc();
public:
//- Runtime type information
TypeName("blendingFactor");
// Constructors
//- Construct for given objectRegistry and dictionary.
// Allow the possibility to load fields from files
blendingFactor
(
const word& name,
const objectRegistry&,
const dictionary&,
const bool loadFromFiles = false
);
//- Destructor
virtual ~blendingFactor();
// Member Functions
//- Return name of the set of blendingFactor
virtual const word& name() const
{
return name_;
}
//- Read the blendingFactor data
virtual void read(const dictionary&);
//- Execute, currently does nothing
virtual void execute();
//- Execute at the final time-loop, currently does nothing
virtual void end();
//- Called when time was set at the end of the Time::operator++
virtual void timeSet();
//- Calculate the blendingFactor and write
virtual void write();
//- Update for changes of mesh
virtual void updateMesh(const mapPolyMesh&)
{}
//- Update for changes of mesh
virtual void movePoints(const polyMesh&)
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "blendingFactorTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

42
src/postProcessing/functionObjects/utilities/blendingFactor/blendingFactorFunctionObject.C Normal file
View File

@ -0,0 +1,42 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "blendingFactorFunctionObject.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineNamedTemplateTypeNameAndDebug(blendingFactorFunctionObject, 0);
addToRunTimeSelectionTable
(
functionObject,
blendingFactorFunctionObject,
dictionary
);
}
// ************************************************************************* //

54
src/postProcessing/functionObjects/utilities/blendingFactor/blendingFactorFunctionObject.H Normal file
View File

@ -0,0 +1,54 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
Typedef
Foam::blendingFactorFunctionObject
Description
FunctionObject wrapper around blendingFactor to allow it to be created
via the functions entry within controlDict.
SourceFiles
blendingFactorFunctionObject.C
\*---------------------------------------------------------------------------*/
#ifndef blendingFactorFunctionObject_H
#define blendingFactorFunctionObject_H
#include "blendingFactor.H"
#include "OutputFilterFunctionObject.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef OutputFilterFunctionObject<blendingFactor>
blendingFactorFunctionObject;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

119
src/postProcessing/functionObjects/utilities/blendingFactor/blendingFactorTemplates.C Normal file
View File

@ -0,0 +1,119 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "gaussConvectionScheme.H"
#include "blendedSchemeBase.H"
#include "fvcCellReduce.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type>
Foam::volScalarField& Foam::blendingFactor::factor
(
const GeometricField<Type, fvPatchField, volMesh>& field
)
{
const word fieldName = "blendingFactor:" + field.name();
if (!obr_.foundObject<volScalarField>(fieldName))
{
const fvMesh& mesh = refCast<const fvMesh>(obr_);
volScalarField* factorPtr =
new volScalarField
(
IOobject
(
fieldName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedScalar("0", dimless, 0.0),
zeroGradientFvPatchScalarField::typeName
);
obr_.store(factorPtr);
}
return
const_cast<volScalarField&>
(
obr_.lookupObject<volScalarField>(fieldName)
);
}
template<class Type>
void Foam::blendingFactor::calc()
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
if (!obr_.foundObject<fieldType>(fieldName_))
{
return;
}
const fvMesh& mesh = refCast<const fvMesh>(obr_);
const fieldType& field = mesh.lookupObject<fieldType>(fieldName_);
const word divScheme("div(" + phiName_ + ',' + fieldName_ + ')');
ITstream& its = mesh.divScheme(divScheme);
const surfaceScalarField& phi =
mesh.lookupObject<surfaceScalarField>(phiName_);
tmp<fv::convectionScheme<Type> > cs =
fv::convectionScheme<Type>::New(mesh, phi, its);
const fv::gaussConvectionScheme<Type>& gcs =
refCast<const fv::gaussConvectionScheme<Type> >(cs());
const surfaceInterpolationScheme<Type>& interpScheme =
gcs.interpScheme();
if (!isA<blendedSchemeBase<Type> >(interpScheme))
{
FatalErrorIn("void Foam::blendingFactor::execute()")
<< interpScheme.typeName << " is not a blended scheme"
<< exit(FatalError);
}
// retrieve the face-based blending factor
const blendedSchemeBase<Type>& blendedScheme =
refCast<const blendedSchemeBase<Type> >(interpScheme);
const surfaceScalarField factorf(blendedScheme.blendingFactor(field));
// convert into vol field whose values represent the local face maxima
volScalarField& factor = this->factor(field);
factor = fvc::cellReduce(factorf, maxEqOp<scalar>());
factor.correctBoundaryConditions();
}
// ************************************************************************* //

4
src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/externalWallHeatFluxTemperature/externalWallHeatFluxTemperatureFvPatchScalarField.C
View File

@ -263,9 +263,9 @@ void Foam::externalWallHeatFluxTemperatureFvPatchScalarField::updateCoeffs()
forAll (thicknessLayers_, iLayer)
{
const scalar l = thicknessLayers_[iLayer];
if (l > 0.0)
if (kappaLayers_[iLayer] > 0.0)
{
totalSolidRes += kappaLayers_[iLayer]/l;
totalSolidRes += l/kappaLayers_[iLayer];
}
}
}

5
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/T
View File

@ -44,6 +44,11 @@ boundaryField
{
type empty;
}
processor
{
type processor;
value $internalField;
}
}

3
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/U
View File

@ -21,6 +21,9 @@ internalField uniform (0.1 0 0);
boundaryField
{
//- Set patchGroups for constraint patches
#include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
floor
{
type fixedValue;

3
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/alphat
View File

@ -21,6 +21,9 @@ internalField uniform 0;
boundaryField
{
//- Set patchGroups for constraint patches
#include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
floor
{
type compressible::alphatWallFunction;

3
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/epsilon
View File

@ -21,6 +21,9 @@ internalField uniform 0.01;
boundaryField
{
//- Set patchGroups for constraint patches
#include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
floor
{
type compressible::epsilonWallFunction;

3
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/k
View File

@ -21,6 +21,9 @@ internalField uniform 0.1;
boundaryField
{
//- Set patchGroups for constraint patches
#include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
floor
{
type compressible::kqRWallFunction;

3
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/mut
View File

@ -21,6 +21,9 @@ internalField uniform 0;
boundaryField
{
//- Set patchGroups for constraint patches
#include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
floor
{
type mutkWallFunction;

3
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/p
View File

@ -21,6 +21,9 @@ internalField uniform 101325;
boundaryField
{
//- Set patchGroups for constraint patches
#include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
floor
{
type calculated;

3
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/p_rgh
View File

@ -21,6 +21,9 @@ internalField uniform 101325;
boundaryField
{
//- Set patchGroups for constraint patches
#include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
floor
{
type fixedFluxPressure;

5
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/createBafflesDict
View File

@ -52,8 +52,9 @@ baffles
{
type mappedWall;
sampleMode nearestPatchFace;
//Group master and slave in different groups. (default off)
groupBase on;
// Put master and slave patch in same group (default on)
// Otherwise makeup group names xxx_master and xxx_slave
sameGroup off;
patchFields
{
#include "./0/include/wallBafflePatches"

52
tutorials/incompressible/pimpleFoam/pitzDaily/0/U Normal file
View File

@ -0,0 +1,52 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0 0 0);
boundaryField
{
inlet
{
type fixedValue;
value uniform (10 0 0);
}
outlet
{
type zeroGradient;
}
upperWall
{
type fixedValue;
value uniform (0 0 0);
}
lowerWall
{
type fixedValue;
value uniform (0 0 0);
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

50
tutorials/incompressible/pimpleFoam/pitzDaily/0/epsilon Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object epsilon;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -3 0 0 0 0];
internalField uniform 14.855;
boundaryField
{
inlet
{
type fixedValue;
value uniform 14.855;
}
outlet
{
type zeroGradient;
}
upperWall
{
type epsilonWallFunction;
value uniform 14.855;
}
lowerWall
{
type epsilonWallFunction;
value uniform 14.855;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

50
tutorials/incompressible/pimpleFoam/pitzDaily/0/k Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object k;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 0.375;
boundaryField
{
inlet
{
type fixedValue;
value uniform 0.375;
}
outlet
{
type zeroGradient;
}
upperWall
{
type kqRWallFunction;
value uniform 0.375;
}
lowerWall
{
type kqRWallFunction;
value uniform 0.375;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

50
tutorials/incompressible/pimpleFoam/pitzDaily/0/nuTilda Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object nuTilda;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type fixedValue;
value uniform 0;
}
outlet
{
type zeroGradient;
}
upperWall
{
type zeroGradient;
}
lowerWall
{
type zeroGradient;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

51
tutorials/incompressible/pimpleFoam/pitzDaily/0/nut Normal file
View File

@ -0,0 +1,51 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object nut;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type calculated;
value uniform 0;
}
outlet
{
type calculated;
value uniform 0;
}
upperWall
{
type nutkWallFunction;
value uniform 0;
}
lowerWall
{
type nutkWallFunction;
value uniform 0;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

50
tutorials/incompressible/pimpleFoam/pitzDaily/0/p Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type zeroGradient;
}
outlet
{
type fixedValue;
value uniform 0;
}
upperWall
{
type zeroGradient;
}
lowerWall
{
type zeroGradient;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //

25
tutorials/incompressible/pimpleFoam/pitzDaily/constant/RASProperties Normal file
View File

@ -0,0 +1,25 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object RASProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
RASModel kEpsilon;
turbulence on;
printCoeffs on;
// ************************************************************************* //

173
tutorials/incompressible/pimpleFoam/pitzDaily/constant/polyMesh/blockMeshDict Normal file
View File

@ -0,0 +1,173 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 0.001;
vertices
(
(-20.6 0 -0.5)
(-20.6 3 -0.5)
(-20.6 12.7 -0.5)
(-20.6 25.4 -0.5)
(0 -25.4 -0.5)
(0 -5 -0.5)
(0 0 -0.5)
(0 3 -0.5)
(0 12.7 -0.5)
(0 25.4 -0.5)
(206 -25.4 -0.5)
(206 -8.5 -0.5)
(206 0 -0.5)
(206 6.5 -0.5)
(206 17 -0.5)
(206 25.4 -0.5)
(290 -16.6 -0.5)
(290 -6.3 -0.5)
(290 0 -0.5)
(290 4.5 -0.5)
(290 11 -0.5)
(290 16.6 -0.5)
(-20.6 0 0.5)
(-20.6 3 0.5)
(-20.6 12.7 0.5)
(-20.6 25.4 0.5)
(0 -25.4 0.5)
(0 -5 0.5)
(0 0 0.5)
(0 3 0.5)
(0 12.7 0.5)
(0 25.4 0.5)
(206 -25.4 0.5)
(206 -8.5 0.5)
(206 0 0.5)
(206 6.5 0.5)
(206 17 0.5)
(206 25.4 0.5)
(290 -16.6 0.5)
(290 -6.3 0.5)
(290 0 0.5)
(290 4.5 0.5)
(290 11 0.5)
(290 16.6 0.5)
);
blocks
(
hex (0 6 7 1 22 28 29 23) (18 7 1) simpleGrading (0.5 1.8 1)
hex (1 7 8 2 23 29 30 24) (18 10 1) simpleGrading (0.5 4 1)
hex (2 8 9 3 24 30 31 25) (18 13 1) simpleGrading (0.5 0.25 1)
hex (4 10 11 5 26 32 33 27) (180 18 1) simpleGrading (4 1 1)
hex (5 11 12 6 27 33 34 28) (180 9 1) edgeGrading (4 4 4 4 0.5 1 1 0.5 1 1 1 1)
hex (6 12 13 7 28 34 35 29) (180 7 1) edgeGrading (4 4 4 4 1.8 1 1 1.8 1 1 1 1)
hex (7 13 14 8 29 35 36 30) (180 10 1) edgeGrading (4 4 4 4 4 1 1 4 1 1 1 1)
hex (8 14 15 9 30 36 37 31) (180 13 1) simpleGrading (4 0.25 1)
hex (10 16 17 11 32 38 39 33) (25 18 1) simpleGrading (2.5 1 1)
hex (11 17 18 12 33 39 40 34) (25 9 1) simpleGrading (2.5 1 1)
hex (12 18 19 13 34 40 41 35) (25 7 1) simpleGrading (2.5 1 1)
hex (13 19 20 14 35 41 42 36) (25 10 1) simpleGrading (2.5 1 1)
hex (14 20 21 15 36 42 43 37) (25 13 1) simpleGrading (2.5 0.25 1)
);
edges
(
);
boundary
(
inlet
{
type patch;
faces
(
(0 22 23 1)
(1 23 24 2)
(2 24 25 3)
);
}
outlet
{
type patch;
faces
(
(16 17 39 38)
(17 18 40 39)
(18 19 41 40)
(19 20 42 41)
(20 21 43 42)
);
}
upperWall
{
type wall;
faces
(
(3 25 31 9)
(9 31 37 15)
(15 37 43 21)
);
}
lowerWall
{
type wall;
faces
(
(0 6 28 22)
(6 5 27 28)
(5 4 26 27)
(4 10 32 26)
(10 16 38 32)
);
}
frontAndBack
{
type empty;
faces
(
(22 28 29 23)
(23 29 30 24)
(24 30 31 25)
(26 32 33 27)
(27 33 34 28)
(28 34 35 29)
(29 35 36 30)
(30 36 37 31)
(32 38 39 33)
(33 39 40 34)
(34 40 41 35)
(35 41 42 36)
(36 42 43 37)
(0 1 7 6)
(1 2 8 7)
(2 3 9 8)
(4 5 11 10)
(5 6 12 11)
(6 7 13 12)
(7 8 14 13)
(8 9 15 14)
(10 11 17 16)
(11 12 18 17)
(12 13 19 18)
(13 14 20 19)
(14 15 21 20)
);
}
);
mergePatchPairs
(
);
// ************************************************************************* //

53
tutorials/incompressible/pimpleFoam/pitzDaily/constant/polyMesh/boundary Normal file
View File

@ -0,0 +1,53 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.2.x |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class polyBoundaryMesh;
location "constant/polyMesh";
object boundary;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
5
(
inlet
{
type patch;
nFaces 30;
startFace 24170;
}
outlet
{
type patch;
nFaces 57;
startFace 24200;
}
upperWall
{
type wall;
nFaces 223;
startFace 24257;
}
lowerWall
{
type wall;
nFaces 250;
startFace 24480;
}
frontAndBack
{
type empty;
inGroups 1(empty);
nFaces 24450;
startFace 24730;
}
)
// ************************************************************************* //

39
tutorials/incompressible/pimpleFoam/pitzDaily/constant/transportProperties Normal file
View File

@ -0,0 +1,39 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object transportProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
transportModel Newtonian;
nu nu [ 0 2 -1 0 0 0 0 ] 1e-05;
CrossPowerLawCoeffs
{
nu0 nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
nuInf nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
m m [ 0 0 1 0 0 0 0 ] 1;
n n [ 0 0 0 0 0 0 0 ] 1;
}
BirdCarreauCoeffs
{
nu0 nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
nuInf nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
k k [ 0 0 1 0 0 0 0 ] 0;
n n [ 0 0 0 0 0 0 0 ] 1;
}
// ************************************************************************* //

20
tutorials/incompressible/pimpleFoam/pitzDaily/constant/turbulenceProperties Normal file
View File

@ -0,0 +1,20 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "constant";
object turbulenceProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType RASModel;
// ************************************************************************* //

52
tutorials/incompressible/pimpleFoam/pitzDaily/system/controlDict Normal file
View File

@ -0,0 +1,52 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application pimpleFoam;
startFrom latestTime;
startTime 0;
stopAt endTime;
endTime 1;
deltaT 0.0001;
writeControl adjustableRunTime;
writeInterval 0.001;
purgeWrite 0;
writeFormat ascii;
writePrecision 6;
writeCompression off;
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
adjustTimeStep yes;
maxCo 5;
// ************************************************************************* //

71
tutorials/incompressible/pimpleFoam/pitzDaily/system/fvSchemes Normal file
View File

@ -0,0 +1,71 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
grad(p) Gauss linear;
grad(U) Gauss linear;
}
divSchemes
{
default none;
div(phi,U) bounded Gauss linearUpwind grad(U);
div(phi,k) bounded Gauss upwind;
div(phi,epsilon) bounded Gauss upwind;
div(phi,R) bounded Gauss upwind;
div(R) Gauss linear;
div(phi,nuTilda) bounded Gauss upwind;
div((nuEff*dev(T(grad(U))))) Gauss linear;
}
laplacianSchemes
{
default none;
laplacian(nuEff,U) Gauss linear corrected;
laplacian(rAUf,p) Gauss linear corrected;
laplacian(DkEff,k) Gauss linear corrected;
laplacian(DepsilonEff,epsilon) Gauss linear corrected;
laplacian(DREff,R) Gauss linear corrected;
laplacian(DnuTildaEff,nuTilda) Gauss linear corrected;
}
interpolationSchemes
{
default linear;
interpolate(U) linear;
}
snGradSchemes
{
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

62
tutorials/incompressible/pimpleFoam/pitzDaily/system/fvSolution Normal file
View File

@ -0,0 +1,62 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
p
{
solver GAMG;
tolerance 1e-7;
relTol 0.01;
smoother GaussSeidel;
cacheAgglomeration true;
nCellsInCoarsestLevel 10;
agglomerator faceAreaPair;
mergeLevels 1;
}
pFinal
{
$p;
relTol 0;
}
"(U|k|epsilon)"
{
solver PBiCG;
preconditioner DILU;
tolerance 1e-05;
relTol 0.1;
}
"(U|k|epsilon)Final"
{
$U;
relTol 0;
}
}
PIMPLE
{
nNonOrthogonalCorrectors 0;
nCorrectors 2;
}
// ************************************************************************* //