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/OpenFOAM-dev

Browse Source
This commit is contained in:
Henry
2012-07-09 08:52:53 +01:00
parent 327ebcbcfa a40ebc83ea
commit 772be84dde
20 changed files with 428 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -40,6 +40,7 @@ Description
#include "refinementFeatures.H"
#include "shellSurfaces.H"
#include "decompositionMethod.H"
#include "noDecomp.H"
#include "fvMeshDistribute.H"
#include "wallPolyPatch.H"
#include "refinementParameters.H"
@ -176,17 +177,27 @@ int main(int argc, char *argv[])
// Read decomposePar dictionary
IOdictionary decomposeDict
(
IOobject
dictionary decomposeDict;
{
IOobject io
(
"decomposeParDict",
runTime.system(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
);
if (io.headerOk())
{
decomposeDict = IOdictionary(io);
}
else
{
decomposeDict.add("method", "none");
decomposeDict.add("numberOfSubdomains", 1);
}
}
// Debug

16
applications/utilities/miscellaneous/patchSummary/patchSummary.C
View File

@ -191,6 +191,22 @@ int main(int argc, char *argv[])
outputFieldList<tensor>(vtf, patchIDs[0]);
Info<< endl;
}
else
{
// No group.
forAll(patchIDs, i)
{
label patchI = patchIDs[i];
Info<< bm[patchI].type()
<< "\t: " << bm[patchI].name() << nl;
outputFieldList<scalar>(vsf, patchI);
outputFieldList<vector>(vvf, patchI);
outputFieldList<sphericalTensor>(vsptf, patchI);
outputFieldList<symmTensor>(vsytf, patchI);
outputFieldList<tensor>(vtf, patchI);
Info<< endl;
}
}
}
}
}

2
applications/utilities/postProcessing/wall/solidWallHeatFlux/createFields.H
View File

@ -3,4 +3,4 @@ autoPtr<solidThermo> thermo
solidThermo::New(mesh)
);
volScalarField& T = thermo->T();
const volScalarField& T = thermo->T();

136
src/finiteVolume/finiteVolume/gradSchemes/extendedLeastSquaresGrad/extendedLeastSquaresVectors.C
View File

@ -110,6 +110,38 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
const labelUList& owner = mesh_.owner();
const labelUList& neighbour = mesh_.neighbour();
// Determine number of dimensions and (for 2D) missing dimension
label nDims = 0;
label twoD = -1;
for (direction dir = 0; dir < vector::nComponents; dir++)
{
if (mesh.geometricD()[dir] == 1)
{
nDims++;
}
else
{
twoD = dir;
}
}
if (nDims == 1)
{
FatalErrorIn
(
"extendedLeastSquaresVectors::makeLeastSquaresVectors() const"
) << "Found a mesh with only one geometric dimension : "
<< mesh.geometricD()
<< exit(FatalError);
}
else if (nDims == 2)
{
Info<< "extendedLeastSquares : detected " << nDims
<< " valid directions. Missing direction " << twoD << nl << endl;
}
const volVectorField& C = mesh.C();
// Set up temporary storage for the dd tensor (before inversion)
@ -122,7 +154,7 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
vector d = C[nei] - C[own];
const symmTensor wdd(1.0/magSqr(d[facei])*sqr(d[facei]));
const symmTensor wdd(1.0/magSqr(d)*sqr(d));
dd[own] += wdd;
dd[nei] += wdd;
@ -147,6 +179,28 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
}
}
// Check for missing dimensions
// Add the missing eigenvector (such that it does not
// affect the determinant)
if (nDims == 2)
{
forAll(dd, cellI)
{
if (twoD == 0)
{
dd[cellI].xx() = 1;
}
else if (twoD == 1)
{
dd[cellI].yy() = 1;
}
else
{
dd[cellI].zz() = 1;
}
}
}
scalarField detdd(det(dd));
Info<< "max(detdd) = " << max(detdd) << nl
@ -170,7 +224,8 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
(
"extendedLeastSquaresVectors::"
"makeLeastSquaresVectors() const"
) << "nAddCells exceeds maxNaddCells"
) << "nAddCells exceeds maxNaddCells ("
<< maxNaddCells << ")"
<< exit(FatalError);
}
@ -188,20 +243,35 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
if (cellj != i)
{
if (cellj != -1)
vector dCij = (mesh.C()[cellj] - mesh.C()[i]);
symmTensor ddij =
dd[i] + (1.0/magSqr(dCij))*sqr(dCij);
// Add the missing eigenvector (such that it does not
// affect the determinant)
if (nDims == 2)
{
vector dCij = (mesh.C()[cellj] - mesh.C()[i]);
symmTensor ddij =
dd[i] + (1.0/magSqr(dCij))*sqr(dCij);
scalar detddij = det(ddij);
if (detddij > maxDetddij)
if (twoD == 0)
{
addCell = cellj;
maxDetddij = detddij;
ddij.xx() = 1;
}
else if (twoD == 1)
{
ddij.yy() = 1;
}
else
{
ddij.zz() = 1;
}
}
scalar detddij = det(ddij);
if (detddij > maxDetddij)
{
addCell = cellj;
maxDetddij = detddij;
}
}
}
@ -213,6 +283,25 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
additionalCells_[nAddCells++][1] = addCell;
vector dCij = mesh.C()[addCell] - mesh.C()[i];
dd[i] += (1.0/magSqr(dCij))*sqr(dCij);
// Add the missing eigenvector (such that it does not
// affect the determinant)
if (nDims == 2)
{
if (twoD == 0)
{
dd[i].xx() = 1;
}
else if (twoD == 1)
{
dd[i].yy() = 1;
}
else
{
dd[i].zz() = 1;
}
}
detdd[i] = det(dd[i]);
}
}
@ -220,10 +309,16 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
additionalCells_.setSize(nAddCells);
Info<< "max(detdd) = " << max(detdd) << nl
<< "min(detdd) = " << min(detdd) << nl
<< "average(detdd) = " << average(detdd) << nl
<< "nAddCells/nCells = " << scalar(nAddCells)/mesh.nCells() << endl;
reduce(nAddCells, sumOp<label>());
if (nAddCells)
{
Info<< "max(detdd) = " << max(detdd) << nl
<< "min(detdd) = " << min(detdd) << nl
<< "average(detdd) = " << average(detdd) << nl
<< "nAddCells/nCells = "
<< scalar(nAddCells)/mesh.globalData().nTotalCells()
<< endl;
}
// Invert the dd tensor
const symmTensorField invDd(inv(dd));
@ -237,11 +332,8 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
vector d = C[nei] - C[own];
lsP[facei] =
(1.0/magSqr(d[facei]))*(invDd[owner[facei]] & d);
lsN[facei] =
((-1.0)/magSqr(d[facei]))*(invDd[neighbour[facei]] & d);
lsP[facei] = (1.0/magSqr(d))*(invDd[own] & d);
lsN[facei] = ((-1.0)/magSqr(d))*(invDd[nei] & d);
}
forAll(blsP, patchI)

44
src/meshTools/algorithms/MeshWave/FaceCellWave.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-2012 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -814,7 +814,27 @@ Foam::FaceCellWave<Type, TrackingData>::FaceCellWave
nEvals_(0),
nUnvisitedCells_(mesh_.nCells()),
nUnvisitedFaces_(mesh_.nFaces())
{}
{
if
(
allFaceInfo.size() != mesh_.nFaces()
|| allCellInfo.size() != mesh_.nCells()
)
{
FatalErrorIn
(
"FaceCellWave<Type, TrackingData>::FaceCellWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" UList<Type>&, UList<Type>&, const label maxIter)"
) << "face and cell storage not the size of mesh faces, cells:"
<< endl
<< " allFaceInfo :" << allFaceInfo.size() << endl
<< " mesh_.nFaces():" << mesh_.nFaces() << endl
<< " allCellInfo :" << allCellInfo.size() << endl
<< " mesh_.nCells():" << mesh_.nCells()
<< exit(FatalError);
}
}
// Iterate, propagating changedFacesInfo across mesh, until no change (or
@ -850,6 +870,26 @@ Foam::FaceCellWave<Type, TrackingData>::FaceCellWave
nUnvisitedCells_(mesh_.nCells()),
nUnvisitedFaces_(mesh_.nFaces())
{
if
(
allFaceInfo.size() != mesh_.nFaces()
|| allCellInfo.size() != mesh_.nCells()
)
{
FatalErrorIn
(
"FaceCellWave<Type, TrackingData>::FaceCellWave"
"(const polyMesh&, const labelList&, const List<Type>,"
" UList<Type>&, UList<Type>&, const label maxIter)"
) << "face and cell storage not the size of mesh faces, cells:"
<< endl
<< " allFaceInfo :" << allFaceInfo.size() << endl
<< " mesh_.nFaces():" << mesh_.nFaces() << endl
<< " allCellInfo :" << allCellInfo.size() << endl
<< " mesh_.nCells():" << mesh_.nCells()
<< exit(FatalError);
}
// Copy initial changed faces data
setFaceInfo(changedFaces, changedFacesInfo);

1
src/parallel/decompose/decompositionMethods/Make/files
View File

@ -6,5 +6,6 @@ manualDecomp/manualDecomp.C
multiLevelDecomp/multiLevelDecomp.C
structuredDecomp/topoDistanceData.C
structuredDecomp/structuredDecomp.C
noDecomp/noDecomp.C
LIB = $(FOAM_LIBBIN)/libdecompositionMethods

4
src/parallel/decompose/decompositionMethods/manualDecomp/manualDecomp.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-2012 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -111,7 +111,7 @@ public:
notImplemented
(
"decompose(const labelListList&, const pointField&"
", const scalarField)"
", const scalarField&)"
);
return labelList(0);
}

53
src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.C Normal file
View File

@ -0,0 +1,53 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "noDecomp.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTypeName(noDecomp);
addNamedToRunTimeSelectionTable
(
decompositionMethod,
noDecomp,
dictionary,
none
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::noDecomp::noDecomp(const dictionary& decompositionDict)
:
decompositionMethod(decompositionDict)
{}
// ************************************************************************* //

134
src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.H Normal file
View File

@ -0,0 +1,134 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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::noDecomp
Description
Dummy decomposition method
SourceFiles
noDecomp.C
\*---------------------------------------------------------------------------*/
#ifndef noDecomp_H
#define noDecomp_H
#include "decompositionMethod.H"
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class noDecomp Declaration
\*---------------------------------------------------------------------------*/
class noDecomp
:
public decompositionMethod
{
// Private Member Functions
//- Disallow default bitwise copy construct and assignment
void operator=(const noDecomp&);
noDecomp(const noDecomp&);
public:
//- Runtime type information
TypeName("noDecomp");
// Constructors
//- Construct given the decomposition dictionary
noDecomp(const dictionary& decompositionDict);
//- Destructor
virtual ~noDecomp()
{}
// Member Functions
//- manual decompose does not care about proc boundaries - is all
// up to the user.
virtual bool parallelAware() const
{
return false;
}
//- Return for every coordinate the wanted processor number. Use the
// mesh connectivity (if needed)
virtual labelList decompose
(
const polyMesh& mesh,
const pointField& cc,
const scalarField& cWeights
)
{
notImplemented
(
"decompose(const polyMesh&, const pointField&"
", const scalarField&)"
);
return labelList(0);
}
//- Return for every coordinate the wanted processor number. Explicitly
// provided connectivity - does not use mesh_.
// The connectivity is equal to mesh.cellCells() except for
// - in parallel the cell numbers are global cell numbers (starting
// from 0 at processor0 and then incrementing all through the
// processors)
// - the connections are across coupled patches
virtual labelList decompose
(
const labelListList& globalCellCells,
const pointField& cc,
const scalarField& cWeights
)
{
notImplemented
(
"decompose(const labelListList&, const pointField&"
", const scalarField&)"
);
return labelList(0);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

33
src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMaxTemplates.C
View File

@ -73,16 +73,16 @@ void Foam::fieldMinMax::calcMinMaxFields
Pstream::gatherList(maxVs);
Pstream::gatherList(maxCs);
label minI = findMin(minVs);
scalar minValue = minVs[minI];
const vector& minC = minCs[minI];
label maxI = findMax(maxVs);
scalar maxValue = maxVs[maxI];
const vector& maxC = maxCs[maxI];
if (Pstream::master())
{
label minI = findMin(minVs);
scalar minValue = minVs[minI];
const vector& minC = minCs[minI];
label maxI = findMax(maxVs);
scalar maxValue = maxVs[maxI];
const vector& maxC = maxCs[maxI];
if (write_)
{
fieldMinMaxFilePtr_()
@ -153,17 +153,16 @@ void Foam::fieldMinMax::calcMinMaxFields
Pstream::gatherList(maxVs);
Pstream::gatherList(maxCs);
label minI = findMin(minVs);
Type minValue = minVs[minI];
const vector& minC = minCs[minI];
label maxI = findMax(maxVs);
Type maxValue = maxVs[maxI];
const vector& maxC = maxCs[maxI];
if (Pstream::master())
{
label minI = findMin(minVs);
Type minValue = minVs[minI];
const vector& minC = minCs[minI];
label maxI = findMax(maxVs);
Type maxValue = maxVs[maxI];
const vector& maxC = maxCs[maxI];
if (write_)
{
fieldMinMaxFilePtr_()

4
src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
View File

@ -349,7 +349,7 @@ reactingOneDim::reactingOneDim(const word& modelType, const fvMesh& mesh)
pyrolysisModel(modelType, mesh),
solidChemistry_(solidChemistryModel::New(regionMesh())),
solidThermo_(solidChemistry_->solid()),
rho_(solidThermo_.rhos()),
rho_(solidThermo_.rho()),
Ys_(solidThermo_.composition().Y()),
h_(solidThermo_.he()),
primaryRadFluxName_(coeffs().lookupOrDefault<word>("radFluxName", "Qr")),
@ -449,7 +449,7 @@ reactingOneDim::reactingOneDim
pyrolysisModel(modelType, mesh, dict),
solidChemistry_(solidChemistryModel::New(regionMesh())),
solidThermo_(solidChemistry_->solid()),
rho_(solidThermo_.rhos()),
rho_(solidThermo_.rho()),
Ys_(solidThermo_.composition().Y()),
h_(solidThermo_.he()),
primaryRadFluxName_(dict.lookupOrDefault<word>("radFluxName", "Qr")),

2
src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.C
View File

@ -359,7 +359,7 @@ void thermoBaffle2D::info() const
(
mag(regionMesh().Sf().boundaryField()[patchI])
* ph.snGrad()
* thermo_->alpha(patchI)
* thermo_->alpha().boundaryField()[patchI]
) << endl;
}
}

55
src/thermophysicalModels/basic/basicThermo/basicThermo.C
View File

@ -40,62 +40,7 @@ namespace Foam
defineTypeNameAndDebug(basicThermo, 0);
defineRunTimeSelectionTable(basicThermo, fvMesh);
}
/*
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
Foam::wordList Foam::basicThermo::heBoundaryTypes()
{
const volScalarField::GeometricBoundaryField& tbf = T_.boundaryField();
wordList hbt = tbf.types();
forAll(tbf, patchi)
{
if (isA<fixedValueFvPatchScalarField>(tbf[patchi]))
{
hbt[patchi] = fixedEnergyFvPatchScalarField::typeName;
}
else if
(
isA<zeroGradientFvPatchScalarField>(tbf[patchi])
|| isA<fixedGradientFvPatchScalarField>(tbf[patchi])
)
{
hbt[patchi] = gradientEnergyFvPatchScalarField::typeName;
}
else if(isA<mixedFvPatchScalarField>(tbf[patchi]))
{
hbt[patchi] = mixedEnergyFvPatchScalarField::typeName;
}
else if (isA<temperatureJumpFvPatchScalarField>(tbf[patchi]))
{
hbt[patchi] = energyJumpFvPatchScalarField::typeName;
}
}
return hbt;
}
void Foam::basicThermo::heBoundaryCorrection(volScalarField& h)
{
volScalarField::GeometricBoundaryField& hbf = h.boundaryField();
forAll(hbf, patchi)
{
if (isA<gradientEnergyFvPatchScalarField>(hbf[patchi]))
{
refCast<gradientEnergyFvPatchScalarField>(hbf[patchi]).gradient()
= hbf[patchi].fvPatchField::snGrad();
}
else if (isA<mixedEnergyFvPatchScalarField>(hbf[patchi]))
{
refCast<mixedEnergyFvPatchScalarField>(hbf[patchi]).refGrad()
= hbf[patchi].fvPatchField::snGrad();
}
}
}
*/
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

19
src/thermophysicalModels/basic/rhoThermo/rhoThermo/rhoThermo.C
View File

@ -55,6 +55,25 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh)
{}
Foam::rhoThermo::rhoThermo(const fvMesh& mesh, const dictionary& dict)
:
basicThermo(mesh, dict),
rho_
(
IOobject
(
"rhoThermo",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimDensity
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::rhoThermo::~rhoThermo()

3
src/thermophysicalModels/basic/rhoThermo/rhoThermo/rhoThermo.H
View File

@ -90,6 +90,9 @@ public:
//- Construct from mesh
rhoThermo(const fvMesh&);
//- Construct from mesh
rhoThermo(const fvMesh&, const dictionary&);
//- Selector
static autoPtr<rhoThermo> New(const fvMesh&);

3
src/thermophysicalModels/basicSolidThermo/heSolidThermo/heSolidThermo.H
View File

@ -89,9 +89,6 @@ public:
// Derived thermal properties
//- Isotropic thermal conductivity [W/m/K]
//virtual tmp<volScalarField> kappa() const;
//- Anisotropic thermal conductivity [W/m/K]
virtual tmp<volVectorField> Kappa() const;

2
src/thermophysicalModels/basicSolidThermo/solidReactionThermo/solidReactionThermo.C
View File

@ -35,6 +35,7 @@ namespace Foam
defineRunTimeSelectionTable(solidReactionThermo, dictionary);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::solidReactionThermo::solidReactionThermo(const fvMesh& mesh)
@ -52,6 +53,7 @@ Foam::solidReactionThermo::solidReactionThermo
solidThermo(mesh, dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::solidReactionThermo::~solidReactionThermo()

79
src/thermophysicalModels/basicSolidThermo/solidThermo/solidThermo.C
View File

@ -42,20 +42,7 @@ namespace Foam
Foam::solidThermo::solidThermo(const fvMesh& mesh)
:
basicThermo(mesh),
rho_
(
IOobject
(
"rho",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimMass/dimVolume
)
rhoThermo(mesh)
{}
@ -65,20 +52,7 @@ Foam::solidThermo::solidThermo
const dictionary& dict
)
:
basicThermo(mesh, dict),
rho_
(
IOobject
(
"rho",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimMass/dimVolume
)
rhoThermo(mesh, dict)
{}
@ -90,57 +64,10 @@ Foam::solidThermo::~solidThermo()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::volScalarField& Foam::solidThermo::T()
{
return this->T_;
}
const Foam::volScalarField& Foam::solidThermo::T() const
{
return this->T_;
}
const Foam::volScalarField& Foam::solidThermo::rhos() const
{
return rho_;
}
Foam::volScalarField& Foam::solidThermo::rhos()
{
return rho_;
}
const Foam::volScalarField& Foam::solidThermo::p() const
{
return this->p_;
}
Foam::volScalarField& Foam::solidThermo::p()
{
return this->p_;
}
const Foam::volScalarField& Foam::solidThermo::alpha() const
{
return this->alpha_;
}
Foam::tmp<Foam::volScalarField> Foam::solidThermo::rho() const
{
return tmp<volScalarField>(rho_);
}
bool Foam::solidThermo::read()
{
return regIOobject::read();
}
// ************************************************************************* //

92
src/thermophysicalModels/basicSolidThermo/solidThermo/solidThermo.H
View File

@ -41,7 +41,7 @@ SourceFiles
#include "IOdictionary.H"
#include "autoPtr.H"
#include "basicSolidMixture.H"
#include "basicThermo.H"
#include "rhoThermo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -54,18 +54,9 @@ namespace Foam
class solidThermo
:
public basicThermo
public rhoThermo
{
protected:
// Fields
//- Density [kg/m3]
volScalarField rho_;
public:
//- Runtime type information
@ -116,50 +107,9 @@ public:
// Member functions
//- Update properties
virtual void correct() = 0;
// Access to thermodynamic state variables
//- Constant access to temperature [K]
virtual const volScalarField& T() const;
//- Non constant access to temperature [K]
virtual volScalarField& T();
//- Solid density [kg/m3]
virtual const volScalarField& rhos() const;
//- Non-const access for solid density [kg/m3]
virtual volScalarField& rhos();
//- Constant access to p [Pa]
virtual const volScalarField& p() const;
//- Non-constant access to p [Pa]
virtual volScalarField& p();
// Access to transport state variables
//- Thermal diffusivity for enthalpy of mixture [kg/m/s]
virtual const volScalarField& alpha() const;
// Derived thermal properties
//- Enthalpy/Internal energy [J/kg]
virtual const volScalarField& he() const = 0;
//- Enthalpy/Internal energy [J/kg]
// Non-const access allowed for transport equations
virtual volScalarField& he() = 0;
//- Thermal conductivity [W/m/K]
virtual tmp<volScalarField> kappa() const = 0;
//- Thermal conductivity [W/m/K]
virtual tmp<volVectorField> Kappa() const = 0;
@ -172,50 +122,12 @@ public:
//- Emissivity coefficient [1/m]
virtual tmp<volScalarField> emissivity() const = 0;
//- Specific heat capacity [J/kg/K]
virtual tmp<volScalarField> Cp() const = 0;
//- Heat of formation [J/kg]
virtual tmp<volScalarField> hc() const = 0;
//- Density [kg/m^3]
virtual tmp<volScalarField> rho() const;
// Per patch calculation
//- Enthalpy/Internal energy [J/kg]
virtual tmp<scalarField> he
(
const scalarField& p,
const scalarField& T,
const label patchi
) const = 0;
//- Specific heat capacity [J/kg/K)]
virtual tmp<scalarField> Cp
(
const scalarField& p,
const scalarField& T,
const label patchI
) const = 0;
//- Isotropic thermal conductivity [W//m/K]
virtual tmp<scalarField> kappa
(
const label patchI
) const = 0;
//- Anisotropic thermal conductivity [W/m/K]
virtual tmp<vectorField> Kappa
(
const label patchI
) const = 0;
//- Thermal diffusivity for enthalpy of mixture [kg/m/s]
virtual tmp<scalarField> alpha
(
const label patchI
) const = 0;

2
tutorials/incompressible/pisoFoam/les/motorBike/motorBike/system/controlDict
View File

@ -17,7 +17,7 @@ FoamFile
libs ("libOpenFOAM.so" "libfieldFunctionObjects.so");
application simpleFoam;
application pisoFoam;
startFrom latestTime;