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

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];
}
}
}