songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
andy 2012-11-14 17:08:39 +00:00
commit 79d87add02
136 changed files with 1682 additions and 9837 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
applications/solvers/heatTransfer/buoyantSimpleFoam/buoyantSimpleRadiationFoam/buoyantSimpleRadiationFoam.C
View File

@ -36,6 +36,7 @@ Description
#include "fixedGradientFvPatchFields.H"
#include "radiationModel.H"
#include "simpleControl.H"
#include "IOMRFZoneList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -46,6 +47,7 @@ int main(int argc, char *argv[])
#include "createMesh.H"
#include "readGravitationalAcceleration.H"
#include "createFields.H"
#include "createZones.H"
#include "createRadiationModel.H"
#include "initContinuityErrs.H"

11
applications/solvers/multiphase/bubbleFoam/DDtU.H
View File

@ -1,11 +0,0 @@
{
DDtU1 =
fvc::ddt(U1)
+ fvc::div(phi1, U1)
- fvc::div(phi1)*U1;
DDtU2 =
fvc::ddt(U2)
+ fvc::div(phi2, U2)
- fvc::div(phi2)*U2;
}

3
applications/solvers/multiphase/bubbleFoam/Make/files
View File

@ -1,3 +0,0 @@
bubbleFoam.C
EXE = $(FOAM_APPBIN)/bubbleFoam

6
applications/solvers/multiphase/bubbleFoam/Make/options
View File

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

74
applications/solvers/multiphase/bubbleFoam/UEqns.H
View File

@ -1,74 +0,0 @@
fvVectorMatrix U1Eqn(U1, U1.dimensions()*dimVol/dimTime);
fvVectorMatrix U2Eqn(U2, U2.dimensions()*dimVol/dimTime);
{
volTensorField Rc1(-nuEff1*(T(fvc::grad(U1))));
Rc1 = Rc1 + (2.0/3.0)*sqr(Ct)*I*k - (2.0/3.0)*I*tr(Rc1);
surfaceScalarField phiR1
(
- fvc::interpolate(nuEff1)
*mesh.magSf()*fvc::snGrad(alpha1)
/fvc::interpolate(alpha1 + scalar(0.001))
);
U1Eqn =
(
(scalar(1) + Cvm*rho2*alpha2/rho1)*
(
fvm::ddt(U1)
+ fvm::div(phi1, U1, "div(phi1,U1)")
- fvm::Sp(fvc::div(phi1), U1)
)
- fvm::laplacian(nuEff1, U1)
+ fvc::div(Rc1)
+ fvm::div(phiR1, U1, "div(phi1,U1)")
- fvm::Sp(fvc::div(phiR1), U1)
+ (fvc::grad(alpha1)/(fvc::average(alpha1) + scalar(0.001)) & Rc1)
==
// g // Buoyancy term transfered to p-equation
- fvm::Sp(alpha2/rho1*dragCoef, U1)
//+ alpha2/rho1*dragCoef*U2 // Explicit drag transfered to p-equation
- alpha2/rho1*(liftCoeff - Cvm*rho2*DDtU2)
);
U1Eqn.relax();
volTensorField Rc2(-nuEff2*T(fvc::grad(U2)));
Rc2 = Rc2 + (2.0/3.0)*I*k - (2.0/3.0)*I*tr(Rc2);
surfaceScalarField phiR2
(
- fvc::interpolate(nuEff2)
*mesh.magSf()*fvc::snGrad(alpha2)
/fvc::interpolate(alpha2 + scalar(0.001))
);
U2Eqn =
(
(scalar(1) + Cvm*rho2*alpha1/rho2)*
(
fvm::ddt(U2)
+ fvm::div(phi2, U2, "div(phi2,U2)")
- fvm::Sp(fvc::div(phi2), U2)
)
- fvm::laplacian(nuEff2, U2)
+ fvc::div(Rc2)
+ fvm::div(phiR2, U2, "div(phi2,U2)")
- fvm::Sp(fvc::div(phiR2), U2)
+ (fvc::grad(alpha2)/(fvc::average(alpha2) + scalar(0.001)) & Rc2)
==
// g // Buoyancy term transfered to p-equation
- fvm::Sp(alpha1/rho2*dragCoef, U2)
//+ alpha1/rho2*dragCoef*U1 // Explicit drag transfered to p-equation
+ alpha1/rho2*(liftCoeff + Cvm*rho2*DDtU1)
);
U2Eqn.relax();
}

61
applications/solvers/multiphase/bubbleFoam/alphaEqn.H
View File

@ -1,61 +0,0 @@
{
word scheme("div(phi,alpha1)");
surfaceScalarField phir(phi1 - phi2);
Info<< "Max Ur Courant Number = "
<< (
max
(
mesh.surfaceInterpolation::deltaCoeffs()*mag(phir)
/mesh.magSf()
)*runTime.deltaT()
).value()
<< endl;
for (int acorr=0; acorr<nAlphaCorr; acorr++)
{
fvScalarMatrix alpha1Eqn
(
fvm::ddt(alpha1)
+ fvm::div(phi, alpha1, scheme)
+ fvm::div(-fvc::flux(-phir, alpha2, scheme), alpha1, scheme)
);
alpha1Eqn.relax();
alpha1Eqn.solve();
/*
fvScalarMatrix alpha2Eqn
(
fvm::ddt(alpha2)
+ fvm::div(phi, alpha2, scheme)
+ fvm::div
(
-fvc::flux(phir, scalar(1) - alpha2, scheme),
alpha2,
scheme
)
);
alpha2Eqn.relax();
alpha2Eqn.solve();
alpha1 =
0.5
*(
scalar(1)
+ sqr(scalar(1) - alpha2)
- sqr(scalar(1) - alpha1)
);
*/
alpha2 = scalar(1) - alpha1;
}
Info<< "Dispersed phase volume fraction = "
<< alpha1.weightedAverage(mesh.V()).value()
<< " Min(alpha1) = " << min(alpha1).value()
<< " Max(alpha1) = " << max(alpha1).value()
<< endl;
}
rho = alpha1*rho1 + alpha2*rho2;

110
applications/solvers/multiphase/bubbleFoam/bubbleFoam.C
View File

@ -1,110 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-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/>.
Application
bubbleFoam
Description
Solver for a system of 2 incompressible fluid phases with one phase
dispersed, e.g. gas bubbles in a liquid.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "nearWallDist.H"
#include "wallFvPatch.H"
#include "Switch.H"
#include "pimpleControl.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "readGravitationalAcceleration.H"
#include "createFields.H"
#include "initContinuityErrs.H"
#include "readTimeControls.H"
#include "CourantNo.H"
#include "setInitialDeltaT.H"
pimpleControl pimple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{
#include "readBubbleFoamControls.H"
#include "CourantNo.H"
#include "setDeltaT.H"
runTime++;
Info<< "Time = " << runTime.timeName() << nl << endl;
// --- Pressure-velocity PIMPLE corrector loop
while (pimple.loop())
{
#include "alphaEqn.H"
#include "liftDragCoeffs.H"
#include "UEqns.H"
// --- Pressure corrector loop
while (pimple.correct())
{
#include "pEqn.H"
if (correctAlpha && !pimple.finalIter())
{
#include "alphaEqn.H"
}
}
#include "DDtU.H"
if (pimple.turbCorr())
{
#include "kEpsilon.H"
nuEff1 = sqr(Ct)*nut2 + nu1;
}
}
#include "write.H"
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

195
applications/solvers/multiphase/bubbleFoam/createFields.H
View File

@ -1,195 +0,0 @@
Info<< "Reading field alpha1\n" << endl;
volScalarField alpha1
(
IOobject
(
"alpha1",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
volScalarField alpha2
(
IOobject
(
"alpha2",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
scalar(1) - alpha1
//,alpha1.boundaryField().types()
);
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
(
"p",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field U1\n" << endl;
volVectorField U1
(
IOobject
(
"U1",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field U2\n" << endl;
volVectorField U2
(
IOobject
(
"U2",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
alpha1*U1 + alpha2*U2
);
Info<< "Reading transportProperties\n" << endl;
IOdictionary transportProperties
(
IOobject
(
"transportProperties",
runTime.constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
dimensionedScalar rho1
(
transportProperties.lookup("rho1")
);
dimensionedScalar rho2
(
transportProperties.lookup("rho2")
);
dimensionedScalar nu1
(
transportProperties.lookup("nu1")
);
dimensionedScalar nu2
(
transportProperties.lookup("nu2")
);
dimensionedScalar d1
(
transportProperties.lookup("d1")
);
dimensionedScalar d2
(
transportProperties.lookup("d2")
);
dimensionedScalar Cvm
(
transportProperties.lookup("Cvm")
);
dimensionedScalar Cl
(
transportProperties.lookup("Cl")
);
dimensionedScalar Ct
(
transportProperties.lookup("Ct")
);
#include "createPhi1.H"
#include "createPhi2.H"
surfaceScalarField phi
(
IOobject
(
"phi",
runTime.timeName(),
mesh
),
fvc::interpolate(alpha1)*phi1
+ fvc::interpolate(alpha2)*phi2
);
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh
),
alpha1*rho1 + alpha2*rho2
);
#include "createRASTurbulence.H"
Info<< "Calculating field DDtU1 and DDtU2\n" << endl;
volVectorField DDtU1
(
fvc::ddt(U1)
+ fvc::div(phi1, U1)
- fvc::div(phi1)*U1
);
volVectorField DDtU2
(
fvc::ddt(U2)
+ fvc::div(phi2, U2)
- fvc::div(phi2)*U2
);
Info<< "Calculating field g.h\n" << endl;
volScalarField gh("gh", g & mesh.C());
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, mesh.solutionDict().subDict("PIMPLE"), pRefCell, pRefValue);

67
applications/solvers/multiphase/bubbleFoam/createPhi1.H
View File

@ -1,67 +0,0 @@
IOobject phi1Header
(
"phi1",
runTime.timeName(),
mesh,
IOobject::NO_READ
);
autoPtr<surfaceScalarField> phi1Ptr(NULL);
if (phi1Header.headerOk())
{
Info<< "Reading face flux field phi1\n" << endl;
phi1Ptr.reset
(
new surfaceScalarField
(
IOobject
(
"phi1",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
);
}
else
{
Info<< "Calculating face flux field phi1\n" << endl;
wordList phiTypes
(
U1.boundaryField().size(),
calculatedFvPatchScalarField::typeName
);
forAll(U1.boundaryField(), i)
{
if (isA<fixedValueFvPatchVectorField>(U1.boundaryField()[i]))
{
phiTypes[i] = fixedValueFvPatchScalarField::typeName;
}
}
phi1Ptr.reset
(
new surfaceScalarField
(
IOobject
(
"phi1",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
fvc::interpolate(U1) & mesh.Sf(),
phiTypes
)
);
}
surfaceScalarField& phi1 = phi1Ptr();

67
applications/solvers/multiphase/bubbleFoam/createPhi2.H
View File

@ -1,67 +0,0 @@
IOobject phi2Header
(
"phi2",
runTime.timeName(),
mesh,
IOobject::NO_READ
);
autoPtr<surfaceScalarField> phi2Ptr(NULL);
if (phi2Header.headerOk())
{
Info<< "Reading face flux field phi2\n" << endl;
phi2Ptr.reset
(
new surfaceScalarField
(
IOobject
(
"phi2",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
);
}
else
{
Info<< "Calculating face flux field phi2\n" << endl;
wordList phiTypes
(
U2.boundaryField().size(),
calculatedFvPatchScalarField::typeName
);
forAll(U2.boundaryField(), i)
{
if (isA<fixedValueFvPatchVectorField>(U2.boundaryField()[i]))
{
phiTypes[i] = fixedValueFvPatchScalarField::typeName;
}
}
phi2Ptr.reset
(
new surfaceScalarField
(
IOobject
(
"phi2",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
fvc::interpolate(U2) & mesh.Sf(),
phiTypes
)
);
}
surfaceScalarField& phi2 = phi2Ptr();

23
applications/solvers/multiphase/bubbleFoam/liftDragCoeffs.H
View File

@ -1,23 +0,0 @@
volVectorField Ur(U1 - U2);
volScalarField magUr(mag(Ur));
volScalarField Cd1MagUr
(
(24.0*nu2/d1)*(scalar(1) + 0.15*pow(d1*magUr/nu2, 0.687))
);
volScalarField Cd2MagUr
(
(24.0*nu1/d2)*(scalar(1) + 0.15*pow(d2*magUr/nu1, 0.687))
);
volScalarField dragCoef
(
"Cd",
0.75*(alpha2*rho2*Cd1MagUr/d1 + alpha1*rho1*Cd2MagUr/d2)
);
volVectorField liftCoeff
(
Cl*(alpha2*rho2 + alpha1*rho1)*(Ur ^ fvc::curl(U))
);

94
applications/solvers/multiphase/bubbleFoam/pEqn.H
View File

@ -1,94 +0,0 @@
{
surfaceScalarField alpha1f(fvc::interpolate(alpha1));
surfaceScalarField alpha2f(scalar(1) - alpha1f);
volScalarField rAU1(1.0/U1Eqn.A());
volScalarField rAU2(1.0/U2Eqn.A());
surfaceScalarField rAU1f(fvc::interpolate(rAU1));
surfaceScalarField rAU2f(fvc::interpolate(rAU2));
volVectorField HbyA1("HbyA1", U1);
HbyA1 = rAU1*U1Eqn.H();
volVectorField HbyA2("HbyA2", U2);
HbyA2 = rAU2*U2Eqn.H();
surfaceScalarField phiDrag1
(
fvc::interpolate(alpha2/rho1*dragCoef*rAU1)*phi2
+ rAU1f*(g & mesh.Sf())
);
surfaceScalarField phiDrag2
(
fvc::interpolate(alpha1/rho2*dragCoef*rAU2)*phi1
+ rAU2f*(g & mesh.Sf())
);
forAll(p.boundaryField(), patchi)
{
if (isA<zeroGradientFvPatchScalarField>(p.boundaryField()[patchi]))
{
phiDrag1.boundaryField()[patchi] = 0.0;
phiDrag2.boundaryField()[patchi] = 0.0;
}
}
surfaceScalarField phiHbyA1
(
(fvc::interpolate(HbyA1) & mesh.Sf())
+ fvc::ddtPhiCorr(rAU1, U1, phi1)
);
surfaceScalarField phiHbyA2
(
(fvc::interpolate(HbyA2) & mesh.Sf())
+ fvc::ddtPhiCorr(rAU2, U2, phi2)
);
phi = alpha1f*phiHbyA1 + alpha2f*phiHbyA2;
phiHbyA1 += phiDrag1;
phiHbyA2 += phiDrag2;
surfaceScalarField phiHbyA("phiHbyA", alpha1f*phiHbyA1 + alpha2f*phiHbyA2);
surfaceScalarField Dp
(
"Dp",
alpha1f*rAU1f/rho1 + alpha2f*rAU2f/rho2
);
while (pimple.correctNonOrthogonal())
{
fvScalarMatrix pEqn
(
fvm::laplacian(Dp, p) == fvc::div(phiHbyA)
);
pEqn.setReference(pRefCell, pRefValue);
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
if (pimple.finalNonOrthogonalIter())
{
surfaceScalarField SfGradp(pEqn.flux()/Dp);
phi1 = phiHbyA1 - rAU1f*SfGradp/rho1;
phi2 = phiHbyA2 - rAU2f*SfGradp/rho2;
phi = alpha1f*phi1 + alpha2f*phi2;
p.relax();
SfGradp = pEqn.flux()/Dp;
U1 = HbyA1 + (fvc::reconstruct(phiDrag1 - rAU1f*SfGradp/rho1));
U1.correctBoundaryConditions();
U2 = HbyA2 + (fvc::reconstruct(phiDrag2 - rAU2f*SfGradp/rho2));
U2.correctBoundaryConditions();
U = alpha1*U1 + alpha2*U2;
}
}
}
#include "continuityErrs.H"

4
applications/solvers/multiphase/bubbleFoam/readBubbleFoamControls.H
View File

@ -1,4 +0,0 @@
int nAlphaCorr(readInt(pimple.dict().lookup("nAlphaCorr")));
Switch correctAlpha(pimple.dict().lookup("correctAlpha"));

17
applications/solvers/multiphase/bubbleFoam/write.H
View File

@ -1,17 +0,0 @@
if (runTime.outputTime())
{
volVectorField Ur
(
IOobject
(
"Ur",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
U1 - U2
);
runTime.write();
}

15
applications/solvers/multiphase/settlingFoam/createFields.H
View File

@ -12,12 +12,12 @@
mesh
);
Info<< "Reading field alpha\n" << endl;
volScalarField alpha
Info<< "Reading field Alpha\n" << endl;
volScalarField Alpha
(
IOobject
(
"alpha",
"Alpha",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
@ -100,21 +100,20 @@
IOobject::NO_READ,
IOobject::NO_WRITE
),
(scalar(1) - alpha)*rhoc + alpha*rhod
rhoc/(scalar(1) + (rhoc/rhod - 1.0)*Alpha)
);
volScalarField Alpha
volScalarField alpha
(
IOobject
(
"Alpha",
"alpha",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
alpha*rhod/rho,
alpha.boundaryField().types()
rho*Alpha/rhod
);
#include "compressibleCreatePhi.H"

1
applications/solvers/multiphase/twoPhaseEulerFoam/Make/options
View File

@ -1,5 +1,4 @@
EXE_INC = \
-I../bubbleFoam \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/transportModels/incompressible/lnInclude \
-IturbulenceModel \

0
applications/solvers/multiphase/bubbleFoam/createRASTurbulence.H → applications/solvers/multiphase/twoPhaseEulerFoam/createRASTurbulence.H
View File

0
applications/solvers/multiphase/bubbleFoam/kEpsilon.H → applications/solvers/multiphase/twoPhaseEulerFoam/kEpsilon.H
View File

2
applications/solvers/multiphase/bubbleFoam/wallDissipation.H → applications/solvers/multiphase/twoPhaseEulerFoam/wallDissipation.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

0
applications/solvers/multiphase/bubbleFoam/wallFunctions.H → applications/solvers/multiphase/twoPhaseEulerFoam/wallFunctions.H
View File

0
applications/solvers/multiphase/bubbleFoam/wallViscosity.H → applications/solvers/multiphase/twoPhaseEulerFoam/wallViscosity.H
View File

1
applications/utilities/mesh/advanced/combinePatchFaces/Make/options
View File

@ -5,4 +5,5 @@ EXE_INC = \
EXE_LIBS = \
-lmeshTools \
-lsampling \
-ldynamicMesh

130
applications/utilities/mesh/advanced/combinePatchFaces/combinePatchFaces.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
@ -53,105 +53,19 @@ Description
#include "polyMesh.H"
#include "mapPolyMesh.H"
#include "unitConversion.H"
#include "motionSmoother.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Same check as snapMesh
void checkSnapMesh
(
const Time& runTime,
const polyMesh& mesh,
labelHashSet& wrongFaces
)
{
IOdictionary snapDict
(
IOobject
(
"snapMeshDict",
runTime.system(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
// Max nonorthogonality allowed
scalar maxNonOrtho(readScalar(snapDict.lookup("maxNonOrtho")));
// Max concaveness allowed.
scalar maxConcave(readScalar(snapDict.lookup("maxConcave")));
// Min volume allowed (factor of minimum cellVolume)
scalar relMinVol(readScalar(snapDict.lookup("minVol")));
const scalar minCellVol = min(mesh.cellVolumes());
const scalar minPyrVol = relMinVol*minCellVol;
// Min area
scalar minArea(readScalar(snapDict.lookup("minArea")));
if (maxNonOrtho < 180.0-SMALL)
{
Pout<< "Checking non orthogonality" << endl;
label nOldSize = wrongFaces.size();
mesh.setNonOrthThreshold(maxNonOrtho);
mesh.checkFaceOrthogonality(false, &wrongFaces);
Pout<< "Detected " << wrongFaces.size() - nOldSize
<< " faces with non-orthogonality > " << maxNonOrtho << " degrees"
<< endl;
}
if (minPyrVol > -GREAT)
{
Pout<< "Checking face pyramids" << endl;
label nOldSize = wrongFaces.size();
mesh.checkFacePyramids(false, minPyrVol, &wrongFaces);
Pout<< "Detected additional " << wrongFaces.size() - nOldSize
<< " faces with illegal face pyramids" << endl;
}
if (maxConcave < 180.0-SMALL)
{
Pout<< "Checking face angles" << endl;
label nOldSize = wrongFaces.size();
mesh.checkFaceAngles(false, maxConcave, &wrongFaces);
Pout<< "Detected additional " << wrongFaces.size() - nOldSize
<< " faces with concavity > " << maxConcave << " degrees"
<< endl;
}
if (minArea > -SMALL)
{
Pout<< "Checking face areas" << endl;
label nOldSize = wrongFaces.size();
const scalarField magFaceAreas(mag(mesh.faceAreas()));
forAll(magFaceAreas, faceI)
{
if (magFaceAreas[faceI] < minArea)
{
wrongFaces.insert(faceI);
}
}
Pout<< "Detected additional " << wrongFaces.size() - nOldSize
<< " faces with area < " << minArea << " m^2" << endl;
}
}
// Merge faces on the same patch (usually from exposing refinement)
// Can undo merges if these cause problems.
label mergePatchFaces
(
const scalar minCos,
const scalar concaveSin,
const bool snapMeshDict,
const autoPtr<IOdictionary>& qualDictPtr,
const Time& runTime,
polyMesh& mesh
)
@ -212,9 +126,9 @@ label mergePatchFaces
// Faces in error.
labelHashSet errorFaces;
if (snapMeshDict)
if (qualDictPtr.valid())
{
checkSnapMesh(runTime, mesh, errorFaces);
motionSmoother::checkMesh(false, mesh, qualDictPtr(), errorFaces);
}
else
{
@ -437,8 +351,8 @@ int main(int argc, char *argv[])
);
argList::addBoolOption
(
"snapMesh",
"use system/snapMeshDict"
"meshQuality",
"read user-defined mesh quality criterions from system/meshQualityDict"
);
# include "setRootCase.H"
@ -455,8 +369,8 @@ int main(int argc, char *argv[])
scalar concaveAngle = args.optionLookupOrDefault("concaveAngle", 30.0);
scalar concaveSin = Foam::sin(degToRad(concaveAngle));
const bool snapMeshDict = args.optionFound("snapMesh");
const bool overwrite = args.optionFound("overwrite");
const bool meshQuality = args.optionFound("meshQuality");
Info<< "Merging all faces of a cell" << nl
<< " - which are on the same patch" << nl
@ -468,23 +382,47 @@ int main(int argc, char *argv[])
<< " (sin:" << concaveSin << ')' << nl
<< endl;
autoPtr<IOdictionary> qualDict;
if (meshQuality)
{
Info<< "Enabling user-defined geometry checks." << nl << endl;
qualDict.reset
(
new IOdictionary
(
IOobject
(
"meshQualityDict",
mesh.time().system(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
}
if (!overwrite)
{
runTime++;
}
// Merge faces on same patch
label nChanged = mergePatchFaces
(
minCos,
concaveSin,
snapMeshDict,
qualDict,
runTime,
mesh
);
// Merge points on straight edges and remove unused points
if (snapMeshDict)
if (qualDict.valid())
{
Info<< "Merging all 'loose' points on surface edges, "
<< "regardless of the angle they make." << endl;

2
applications/utilities/mesh/generation/cvMesh/Make/options
View File

@ -17,6 +17,7 @@ EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude
@ -29,5 +30,6 @@ EXE_LIBS = \
-ldecompositionMethods \
-L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
-ledgeMesh \
-lsampling \
-ltriSurface \
-ldynamicMesh

1
applications/utilities/mesh/generation/cvMesh/conformalVoronoiMesh/Make/options
View File

@ -17,6 +17,7 @@ EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I../vectorTools

32
applications/utilities/mesh/generation/cvMesh/cvMesh.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
@ -36,6 +36,7 @@ Description
#include "argList.H"
#include "conformalVoronoiMesh.H"
#include "vtkSetWriter.H"
using namespace Foam;
@ -48,6 +49,11 @@ int main(int argc, char *argv[])
"noFilter",
"Do not filter the mesh"
);
Foam::argList::addBoolOption
(
"checkGeometry",
"check all surface geometry for quality"
);
#include "setRootCase.H"
#include "createTime.H"
@ -55,6 +61,7 @@ int main(int argc, char *argv[])
runTime.functionObjects().off();
const bool noFilter = !args.optionFound("noFilter");
const bool checkGeometry = args.optionFound("checkGeometry");
Info<< "Mesh filtering is " << (noFilter ? "on" : "off") << endl;
@ -74,6 +81,29 @@ int main(int argc, char *argv[])
conformalVoronoiMesh mesh(runTime, cvMeshDict);
if (checkGeometry)
{
const searchableSurfaces& allGeometry = mesh.allGeometry();
// Write some stats
allGeometry.writeStats(List<wordList>(0), Info);
// Check topology
allGeometry.checkTopology(true);
// Check geometry
allGeometry.checkGeometry
(
100.0, // max size ratio
1e-9, // intersection tolerance
autoPtr<writer<scalar> >(new vtkSetWriter<scalar>()),
0.01, // min triangle quality
true
);
return 0;
}
while (runTime.loop())
{
Info<< nl << "Time = " << runTime.timeName() << endl;

2
applications/utilities/mesh/generation/cvMesh/cvMeshSurfaceSimplify/Make/options
View File

@ -9,6 +9,7 @@ EXE_INC = \
-I$(FASTDUALOCTREE_SRC_PATH) \
-I../conformalVoronoiMesh/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude
@ -21,6 +22,7 @@ EXE_LIBS = \
-lconformalVoronoiMesh \
-ldecompositionMethods -L$(FOAM_LIBBIN)/dummy -lscotchDecomp \
-ledgeMesh \
-lsampling \
-ltriSurface \
-lmeshTools \
-ldynamicMesh

2
applications/utilities/mesh/generation/snappyHexMesh/Make/options
View File

@ -3,6 +3,7 @@ EXE_INC = \
-I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
-I$(LIB_SRC)/mesh/autoMesh/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
@ -13,5 +14,6 @@ EXE_LIBS = \
-ldecompositionMethods \
-L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
-lmeshTools \
-lsampling \
-ldynamicMesh \
-lautoMesh

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

@ -46,7 +46,7 @@ Description
#include "refinementParameters.H"
#include "snapParameters.H"
#include "layerParameters.H"
#include "vtkSetWriter.H"
using namespace Foam;
@ -122,6 +122,12 @@ void writeMesh
int main(int argc, char *argv[])
{
# include "addOverwriteOption.H"
Foam::argList::addBoolOption
(
"checkGeometry",
"check all surface geometry for quality"
);
# include "setRootCase.H"
# include "createTime.H"
runTime.functionObjects().off();
@ -131,6 +137,7 @@ int main(int argc, char *argv[])
<< runTime.cpuTimeIncrement() << " s" << endl;
const bool overwrite = args.optionFound("overwrite");
const bool checkGeometry = args.optionFound("checkGeometry");
// Check patches and faceZones are synchronised
mesh.boundaryMesh().checkParallelSync(true);
@ -244,6 +251,56 @@ int main(int argc, char *argv[])
<< mesh.time().cpuTimeIncrement() << " s" << nl << endl;
// Checking only?
if (checkGeometry)
{
// Extract patchInfo
List<wordList> patchTypes(allGeometry.size());
const PtrList<dictionary>& patchInfo = surfaces.patchInfo();
const labelList& surfaceGeometry = surfaces.surfaces();
forAll(surfaceGeometry, surfI)
{
label geomI = surfaceGeometry[surfI];
const wordList& regNames = allGeometry.regionNames()[geomI];
patchTypes[geomI].setSize(regNames.size());
forAll(regNames, regionI)
{
label globalRegionI = surfaces.globalRegion(surfI, regionI);
if (patchInfo.set(globalRegionI))
{
patchTypes[geomI][regionI] =
word(patchInfo[globalRegionI].lookup("type"));
}
else
{
patchTypes[geomI][regionI] = wallPolyPatch::typeName;
}
}
}
// Write some stats
allGeometry.writeStats(patchTypes, Info);
// Check topology
allGeometry.checkTopology(true);
// Check geometry
allGeometry.checkGeometry
(
100.0, // max size ratio
1e-9, // intersection tolerance
autoPtr<writer<scalar> >(new vtkSetWriter<scalar>()),
0.01, // min triangle quality
true
);
return 0;
}
// Read refinement shells
// ~~~~~~~~~~~~~~~~~~~~~~

3
applications/utilities/mesh/manipulation/setsToZones/Make/options
View File

@ -2,4 +2,5 @@ EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude
EXE_LIBS = \
-lmeshTools
-lmeshTools \
-lsampling

14
applications/utilities/mesh/manipulation/setsToZones/setsToZones.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
@ -48,6 +48,7 @@ Description
#include "IFstream.H"
#include "IOobjectList.H"
#include "SortableList.H"
#include "timeSelector.H"
using namespace Foam;
@ -57,6 +58,7 @@ using namespace Foam;
int main(int argc, char *argv[])
{
timeSelector::addOptions(true, false);
argList::addNote
(
"add point/face/cell Zones from similar named point/face/cell Sets"
@ -76,15 +78,7 @@ int main(int argc, char *argv[])
const bool noFlipMap = args.optionFound("noFlipMap");
// Get times list
instantList Times = runTime.times();
label startTime = Times.size()-1;
label endTime = Times.size();
// check -time and -latestTime options
#include "checkTimeOption.H"
runTime.setTime(Times[startTime], startTime);
(void)timeSelector::selectIfPresent(runTime, args);
#include "createNamedPolyMesh.H"

7
applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3Foam.H
View File

@ -446,13 +446,6 @@ class vtkPV3Foam
template<class PatchType>
vtkPolyData* patchVTKMesh(const word& name, const PatchType&);
//- Add face zone mesh
vtkPolyData* faceZoneVTKMesh
(
const fvMesh&,
const labelList& faceLabels
);
//- Add point zone
vtkPolyData* pointZoneVTKMesh
(

3
applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMesh.C
View File

@ -450,7 +450,8 @@ void Foam::vtkPV3Foam::convertMeshFaceZones
<< zoneName << endl;
}
vtkPolyData* vtkmesh = faceZoneVTKMesh(mesh, zMesh[zoneId]);
vtkPolyData* vtkmesh = patchVTKMesh(zoneName, zMesh[zoneId]());
if (vtkmesh)
{
AddToBlock(output, vtkmesh, range, datasetNo, zoneName);

74
applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamMeshZone.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
@ -35,78 +35,6 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
vtkPolyData* Foam::vtkPV3Foam::faceZoneVTKMesh
(
const fvMesh& mesh,
const labelList& faceLabels
)
{
vtkPolyData* vtkmesh = vtkPolyData::New();
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::faceZoneVTKMesh" << endl;
printMemory();
}
// Construct primitivePatch of faces in faceZone
const faceList& meshFaces = mesh.faces();
faceList patchFaces(faceLabels.size());
forAll(faceLabels, faceI)
{
patchFaces[faceI] = meshFaces[faceLabels[faceI]];
}
primitiveFacePatch p(patchFaces, mesh.points());
// The balance of this routine should be identical to patchVTKMesh
// Convert OpenFOAM mesh vertices to VTK
const pointField& points = p.localPoints();
vtkPoints* vtkpoints = vtkPoints::New();
vtkpoints->Allocate(points.size());
forAll(points, i)
{
vtkInsertNextOpenFOAMPoint(vtkpoints, points[i]);
}
vtkmesh->SetPoints(vtkpoints);
vtkpoints->Delete();
// Add faces as polygons
const faceList& faces = p.localFaces();
vtkCellArray* vtkcells = vtkCellArray::New();
vtkcells->Allocate(faces.size());
forAll(faces, faceI)
{
const face& f = faces[faceI];
vtkIdType nodeIds[f.size()];
forAll(f, fp)
{
nodeIds[fp] = f[fp];
}
vtkcells->InsertNextCell(f.size(), nodeIds);
}
vtkmesh->SetPolys(vtkcells);
vtkcells->Delete();
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::faceZoneVTKMesh" << endl;
printMemory();
}
return vtkmesh;
}
vtkPolyData* Foam::vtkPV3Foam::pointZoneVTKMesh
(
const fvMesh& mesh,

38
applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamPointFields.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
@ -129,6 +129,42 @@ void Foam::vtkPV3Foam::convertPointFields
datasetNo
);
}
//
// Convert faceZones - if activated
//
for
(
int partId = arrayRangeFaceZones_.start();
partId < arrayRangeFaceZones_.end();
++partId
)
{
const word zoneName = getPartName(partId);
const label datasetNo = partDataset_[partId];
const label zoneId = mesh.faceZones().findZoneID(zoneName);
if (!partStatus_[partId] || datasetNo < 0 || zoneId < 0)
{
continue;
}
// Extract the field on the zone
Field<Type> fld
(
ptf.internalField(),
mesh.faceZones()[zoneId]().meshPoints()
);
convertPatchPointField
(
fieldName,
fld,
output,
arrayRangeFaceZones_,
datasetNo
);
}
}
}

2
bin/tools/CleanFunctions
View File

@ -101,7 +101,7 @@ cleanCase()
rm -rf constant/tetDualMesh > /dev/null 2>&1
rm -rf VTK > /dev/null 2>&1
rm -f 0/cellLevel 0/pointLevel
rm -f 0/cellLevel 0/pointLevel 0/cellDist constant/cellDecomposition
if [ -e constant/polyMesh/blockMeshDict.m4 ]
then

2
src/OpenFOAM/Make/files
View File

@ -526,7 +526,7 @@ $(Fields)/symmTensorField/symmTensorField.C
$(Fields)/tensorField/tensorField.C
$(Fields)/complexFields/complexFields.C
$(Fields)/labelField/labelIOField.
$(Fields)/labelField/labelIOField.C
$(Fields)/labelField/labelFieldIOField.C
$(Fields)/scalarField/scalarIOField.C
$(Fields)/scalarField/scalarFieldIOField.C

37
src/OpenFOAM/algorithms/subCycle/subCycle.H
View File

@ -51,8 +51,13 @@ class subCycleField
//- Reference to the field being sub-cycled
GeometricField& gf_;
//- Reference to the field old-time field being sub-cycled
// Needed to avoid calls to oldTime() which may cause
// unexpected updates of the old-time field
GeometricField& gf0_;
//- Copy of the "real" old-time value of the field
GeometricField gf0_;
GeometricField gf_0_;
public:
@ -63,19 +68,33 @@ public:
subCycleField(GeometricField& gf)
:
gf_(gf),
gf0_(gf.oldTime())
gf0_(gf.oldTime()),
gf_0_(gf0_.name() + "_", gf0_)
{}
//- Destructor
~subCycleField()
{
// Reset the old-time field
gf0_ = gf_0_;
// Correct the time index of the field to correspond to the global time
gf_.timeIndex() = gf_.time().timeIndex();
gf0_.timeIndex() = gf_.time().timeIndex();
}
// Reset the old-time field value
gf_.oldTime() = gf0_;
gf_.oldTime().timeIndex() = gf0_.timeIndex();
//- Correct the time index of the field to correspond to
// the sub-cycling time.
//
// The time index is incremented to protect the old-time value from
// being updated at the beginning of the time-loop in the case of
// outer iteration
void updateTimeIndex()
{
gf_.timeIndex() = gf_.time().timeIndex() + 1;
gf0_.timeIndex() = gf_.time().timeIndex() + 1;
}
};
@ -106,16 +125,18 @@ public:
//- Construct field and number of sub-cycles
subCycle(GeometricField& gf, const label nSubCycles)
:
subCycleField<GeometricField>(gf),
subCycleTime(const_cast<Time&>(gf.time()), nSubCycles)
{}
{
// Update the field time index to correspond to the sub-cycle time
this->updateTimeIndex();
}
//- Destructor
// End the subCycleTime, which restores the time state
~subCycle()
{
// End the subCycleTime, which restores the time state
endSubCycle();
}
};

6
src/OpenFOAM/dimensionSet/dimensionSet.C
View File

@ -372,6 +372,12 @@ Foam::dimensionSet Foam::sqrt(const dimensionSet& ds)
}
Foam::dimensionSet Foam::cbrt(const dimensionSet& ds)
{
return pow(ds, 1.0/3.0);
}
Foam::dimensionSet Foam::magSqr(const dimensionSet& ds)
{
return pow(ds, 2);

1
src/OpenFOAM/dimensionSet/dimensionSet.H
View File

@ -76,6 +76,7 @@ dimensionSet pow6(const dimensionSet&);
dimensionSet pow025(const dimensionSet&);
dimensionSet sqrt(const dimensionSet&);
dimensionSet cbrt(const dimensionSet&);
dimensionSet magSqr(const dimensionSet&);
dimensionSet mag(const dimensionSet&);
dimensionSet sign(const dimensionSet&);

3
src/OpenFOAM/fields/DimensionedFields/DimensionedScalarField/DimensionedScalarField.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
@ -377,6 +377,7 @@ UNARY_FUNCTION(scalar, scalar, pow5, pow5)
UNARY_FUNCTION(scalar, scalar, pow6, pow6)
UNARY_FUNCTION(scalar, scalar, pow025, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt, cbrt)
UNARY_FUNCTION(scalar, scalar, sign, sign)
UNARY_FUNCTION(scalar, scalar, pos, pos)
UNARY_FUNCTION(scalar, scalar, neg, neg)

3
src/OpenFOAM/fields/DimensionedFields/DimensionedScalarField/DimensionedScalarField.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
@ -85,6 +85,7 @@ UNARY_FUNCTION(scalar, scalar, pow5, pow5)
UNARY_FUNCTION(scalar, scalar, pow6, pow6)
UNARY_FUNCTION(scalar, scalar, pow025, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt, cbrt)
UNARY_FUNCTION(scalar, scalar, sign, sign)
UNARY_FUNCTION(scalar, scalar, pos, pos)
UNARY_FUNCTION(scalar, scalar, neg, neg)

3
src/OpenFOAM/fields/FieldFields/scalarFieldField/scalarFieldField.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
@ -105,6 +105,7 @@ UNARY_FUNCTION(scalar, scalar, pow5)
UNARY_FUNCTION(scalar, scalar, pow6)
UNARY_FUNCTION(scalar, scalar, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt)
UNARY_FUNCTION(scalar, scalar, sign)
UNARY_FUNCTION(scalar, scalar, pos)
UNARY_FUNCTION(scalar, scalar, neg)

3
src/OpenFOAM/fields/FieldFields/scalarFieldField/scalarFieldField.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
@ -98,6 +98,7 @@ UNARY_FUNCTION(scalar, scalar, pow5)
UNARY_FUNCTION(scalar, scalar, pow6)
UNARY_FUNCTION(scalar, scalar, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt)
UNARY_FUNCTION(scalar, scalar, sign)
UNARY_FUNCTION(scalar, scalar, pos)
UNARY_FUNCTION(scalar, scalar, neg)

1
src/OpenFOAM/fields/Fields/scalarField/scalarField.C
View File

@ -128,6 +128,7 @@ UNARY_FUNCTION(scalar, scalar, pow5)
UNARY_FUNCTION(scalar, scalar, pow6)
UNARY_FUNCTION(scalar, scalar, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt)
UNARY_FUNCTION(scalar, scalar, sign)
UNARY_FUNCTION(scalar, scalar, pos)
UNARY_FUNCTION(scalar, scalar, neg)

1
src/OpenFOAM/fields/Fields/scalarField/scalarField.H
View File

@ -103,6 +103,7 @@ UNARY_FUNCTION(scalar, scalar, pow5)
UNARY_FUNCTION(scalar, scalar, pow6)
UNARY_FUNCTION(scalar, scalar, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt)
UNARY_FUNCTION(scalar, scalar, sign)
UNARY_FUNCTION(scalar, scalar, pos)
UNARY_FUNCTION(scalar, scalar, neg)

3
src/OpenFOAM/fields/GeometricFields/GeometricScalarField/GeometricScalarField.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
@ -448,6 +448,7 @@ UNARY_FUNCTION(scalar, scalar, pow5, pow5)
UNARY_FUNCTION(scalar, scalar, pow6, pow6)
UNARY_FUNCTION(scalar, scalar, pow025, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt, cbrt)
UNARY_FUNCTION(scalar, scalar, sign, sign)
UNARY_FUNCTION(scalar, scalar, pos, pos)
UNARY_FUNCTION(scalar, scalar, neg, neg)

3
src/OpenFOAM/fields/GeometricFields/GeometricScalarField/GeometricScalarField.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
@ -93,6 +93,7 @@ UNARY_FUNCTION(scalar, scalar, pow5, pow5)
UNARY_FUNCTION(scalar, scalar, pow6, pow6)
UNARY_FUNCTION(scalar, scalar, pow025, pow025)
UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
UNARY_FUNCTION(scalar, scalar, cbrt, cbrt)
UNARY_FUNCTION(scalar, scalar, sign, sign)
UNARY_FUNCTION(scalar, scalar, pos, pos)
UNARY_FUNCTION(scalar, scalar, neg, neg)

27
src/OpenFOAM/fields/GeometricFields/SlicedGeometricField/SlicedGeometricField.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
@ -24,6 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "SlicedGeometricField.H"
#include "processorFvPatch.H"
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * * //
@ -40,7 +41,8 @@ slicedBoundaryField
(
const Mesh& mesh,
const Field<Type>& completeField,
const bool preserveCouples
const bool preserveCouples,
const bool preserveProcessorOnly
)
{
tmp<FieldField<PatchField, Type> > tbf
@ -52,7 +54,15 @@ slicedBoundaryField
forAll(mesh.boundary(), patchi)
{
if (preserveCouples && mesh.boundary()[patchi].coupled())
if
(
preserveCouples
&& mesh.boundary()[patchi].coupled()
&& (
!preserveProcessorOnly
|| isA<processorFvPatch>(mesh.boundary()[patchi])
)
)
{
// For coupled patched construct the correct patch field type
bf.set
@ -243,7 +253,8 @@ SlicedGeometricField
const dimensionSet& ds,
const Field<Type>& completeIField,
const Field<Type>& completeBField,
const bool preserveCouples
const bool preserveCouples,
const bool preserveProcessorOnly
)
:
GeometricField<Type, PatchField, GeoMesh>
@ -252,7 +263,13 @@ SlicedGeometricField
mesh,
ds,
Field<Type>(),
slicedBoundaryField(mesh, completeBField, preserveCouples)
slicedBoundaryField
(
mesh,
completeBField,
preserveCouples,
preserveProcessorOnly
)
)
{
// Set the internalField to the slice of the complete field

8
src/OpenFOAM/fields/GeometricFields/SlicedGeometricField/SlicedGeometricField.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
@ -83,7 +83,8 @@ private:
(
const Mesh& mesh,
const Field<Type>& completeField,
const bool preserveCouples
const bool preserveCouples,
const bool preserveProcessorOnly = false
);
//- Slice the given field and a create a PtrList of SlicedPatchField
@ -133,7 +134,8 @@ public:
const dimensionSet&,
const Field<Type>& completeIField,
const Field<Type>& completeBField,
const bool preserveCouples=true
const bool preserveCouples=true,
const bool preserveProcessorOnly = false
);
//- Construct from GeometricField. Reuses full internal and

8
src/conversion/meshReader/createPolyBoundary.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
@ -303,14 +303,12 @@ void Foam::meshReader::createPolyBoundary()
Info<< "Added " << nMissingFaces << " unmatched faces" << endl;
// Add missing faces to last patch ('Default_Empty' etc.)
if (nMissingFaces > 0)
{
patchSizes_.last() = nMissingFaces;
}
else
{
patchStarts_.setSize(patchStarts_.size() - 1);
}
// reset the size of the face list
meshFaces_.setSize(nCreatedFaces);

2
src/fieldSources/Make/options
View File

@ -13,5 +13,5 @@ LIB_LIBS = \
-lfiniteVolume \
-lsampling \
-lmeshTools \
-lsolidThermo \
/*-lsolidThermo*/ \
-lcompressibleTurbulenceModel

18
src/finiteVolume/cfdTools/general/MRF/MRFZone.C
View File

@ -296,6 +296,12 @@ Foam::MRFZone::MRFZone
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::vector Foam::MRFZone::Omega() const
{
return omega_->value(mesh_.time().timeOutputValue())*axis_;
}
void Foam::MRFZone::addCoriolis
(
const volVectorField& U,
@ -312,7 +318,7 @@ void Foam::MRFZone::addCoriolis
vectorField& ddtUc = ddtU.internalField();
const vectorField& Uc = U.internalField();
const vector Omega = omega_->value(mesh_.time().timeOutputValue())*axis_;
const vector Omega = this->Omega();
forAll(cells, i)
{
@ -334,7 +340,7 @@ void Foam::MRFZone::addCoriolis(fvVectorMatrix& UEqn) const
vectorField& Usource = UEqn.source();
const vectorField& U = UEqn.psi();
const vector Omega = omega_->value(mesh_.time().timeOutputValue())*axis_;
const vector Omega = this->Omega();
forAll(cells, i)
{
@ -360,7 +366,7 @@ void Foam::MRFZone::addCoriolis
vectorField& Usource = UEqn.source();
const vectorField& U = UEqn.psi();
const vector Omega = omega_->value(mesh_.time().timeOutputValue())*axis_;
const vector Omega = this->Omega();
forAll(cells, i)
{
@ -374,7 +380,7 @@ void Foam::MRFZone::relativeVelocity(volVectorField& U) const
{
const volVectorField& C = mesh_.C();
const vector Omega = omega_->value(mesh_.time().timeOutputValue())*axis_;
const vector Omega = this->Omega();
const labelList& cells = mesh_.cellZones()[cellZoneID_];
@ -412,7 +418,7 @@ void Foam::MRFZone::absoluteVelocity(volVectorField& U) const
{
const volVectorField& C = mesh_.C();
const vector Omega = omega_->value(mesh_.time().timeOutputValue())*axis_;
const vector Omega = this->Omega();
const labelList& cells = mesh_.cellZones()[cellZoneID_];
@ -480,7 +486,7 @@ void Foam::MRFZone::absoluteFlux
void Foam::MRFZone::correctBoundaryVelocity(volVectorField& U) const
{
const vector Omega = omega_->value(mesh_.time().timeOutputValue())*axis_;
const vector Omega = this->Omega();
// Included patches

5
src/finiteVolume/cfdTools/general/MRF/MRFZone.H
View File

@ -47,7 +47,7 @@ SourceFiles
#include "volFieldsFwd.H"
#include "surfaceFieldsFwd.H"
#include "fvMatricesFwd.H"
#include "fvMatrices.H"
#include "mapPolyMesh.H"
#include "DataEntry.H"
#include "autoPtr.H"
@ -164,6 +164,9 @@ public:
//- Return const access to the MRF active flag
inline bool active() const;
//- Return the current Omega vector
vector Omega() const;
// Evaluation

1
src/finiteVolume/cfdTools/general/MRF/MRFZoneTemplates.C
View File

@ -27,6 +27,7 @@ License
#include "fvMesh.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "fvMatrices.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //

31
src/finiteVolume/fvMesh/fvMeshGeometry.C
View File

@ -133,6 +133,8 @@ void fvMesh::makeC() const
<< abort(FatalError);
}
// Construct as slices. Only preserve processor (not e.g. cyclic)
CPtr_ = new slicedVolVectorField
(
IOobject
@ -148,33 +150,10 @@ void fvMesh::makeC() const
*this,
dimLength,
cellCentres(),
faceCentres()
faceCentres(),
true, //preserveCouples
true //preserveProcOnly
);
// Need to correct for cyclics transformation since absolute quantity.
// Ok on processor patches since hold opposite cell centre (no
// transformation)
slicedVolVectorField& C = *CPtr_;
forAll(C.boundaryField(), patchi)
{
if
(
isA<cyclicFvPatchVectorField>(C.boundaryField()[patchi])
|| isA<cyclicAMIFvPatchVectorField>(C.boundaryField()[patchi])
)
{
// Note: cyclic is not slice but proper field
C.boundaryField()[patchi] == static_cast<const vectorField&>
(
static_cast<const List<vector>&>
(
boundary_[patchi].patchSlice(faceCentres())
)
);
}
}
}

1
src/fvMotionSolver/Make/options
View File

@ -3,6 +3,7 @@ EXE_INC = \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/dynamicMesh/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/postProcessing/functionObjects/forces/lnInclude \
LIB_LIBS = \

1
src/mesh/autoMesh/Make/options
View File

@ -4,6 +4,7 @@ EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude \
-I$(LIB_SRC)/edgeMesh/lnInclude \
-I$(LIB_SRC)/surfMesh/lnInclude \
-I$(LIB_SRC)/triSurface/lnInclude

12
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H
View File

@ -167,7 +167,7 @@ class autoSnapDriver
void correctAttraction
(
const DynamicList<point>& surfacePoints,
const DynamicList<label>& surfaceCount,
const DynamicList<label>& surfaceCounts,
const point& edgePt,
const vector& edgeNormal, // normalised normal
const point& pt,
@ -213,7 +213,7 @@ class autoSnapDriver
DynamicList<point>& surfacePoints,
DynamicList<vector>& surfaceNormals,
DynamicList<label>& surfaceCount
DynamicList<label>& surfaceCounts
) const;
void binFeatureFaces
(
@ -224,13 +224,13 @@ class autoSnapDriver
const scalarField& snapDist,
const label pointI,
const List<List<point> >& pointFaceNormals,
const List<List<point> >& pointFaceSurfNormals,
const List<List<point> >& pointFaceDisp,
const List<List<point> >& pointFaceCentres,
DynamicList<point>& surfacePoints,
DynamicList<vector>& surfaceNormals,
DynamicList<label>& surfaceCount
DynamicList<label>& surfaceCounts
) const;
@ -259,7 +259,7 @@ class autoSnapDriver
const indirectPrimitivePatch& pp,
const scalarField& snapDist,
const List<List<point> >& pointFaceNormals,
const List<List<point> >& pointFaceSurfNormals,
const List<List<point> >& pointFaceDisp,
const List<List<point> >& pointFaceCentres,
const labelListList& pointFacePatchID,
@ -277,7 +277,7 @@ class autoSnapDriver
const indirectPrimitivePatch&,
const scalarField&,
const List<List<point> >& pointFaceNormals,
const List<List<point> >& pointFaceSurfNormals,
const List<List<point> >& pointFaceDisp,
const List<List<point> >& pointFaceCentres,
const labelListList& pointFacePatchID,

70
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriverFeature.C
View File

@ -690,7 +690,7 @@ void Foam::autoSnapDriver::calcNearestFacePointProperties
void Foam::autoSnapDriver::correctAttraction
(
const DynamicList<point>& surfacePoints,
const DynamicList<label>& surfaceCount,
const DynamicList<label>& surfaceCounts,
const point& edgePt,
const vector& edgeNormal, // normalised normal
const point& pt,
@ -702,7 +702,7 @@ void Foam::autoSnapDriver::correctAttraction
scalar tang = ((pt-edgePt)&edgeNormal);
labelList order;
Foam::sortedOrder(surfaceCount, order);
Foam::sortedOrder(surfaceCounts, order);
if (order[0] < order[1])
{
@ -763,7 +763,7 @@ void Foam::autoSnapDriver::binFeatureFace
DynamicList<point>& surfacePoints,
DynamicList<vector>& surfaceNormals,
DynamicList<label>& surfaceCount
DynamicList<label>& surfaceCounts
) const
{
// What to do with very far attraction? For now just ignore the face
@ -783,7 +783,7 @@ void Foam::autoSnapDriver::binFeatureFace
)
{
same = true;
surfaceCount[j]++;
surfaceCounts[j]++;
break;
}
}
@ -796,7 +796,7 @@ void Foam::autoSnapDriver::binFeatureFace
{
surfacePoints.append(pt);
surfaceNormals.append(faceSurfaceNormal);
surfaceCount.append(1);
surfaceCounts.append(1);
}
else if (surfacePoints.size() == 2)
{
@ -810,7 +810,7 @@ void Foam::autoSnapDriver::binFeatureFace
// Definitely makes a feature point
surfacePoints.append(pt);
surfaceNormals.append(faceSurfaceNormal);
surfaceCount.append(1);
surfaceCounts.append(1);
}
}
else if (surfacePoints.size() == 3)
@ -834,7 +834,7 @@ void Foam::autoSnapDriver::binFeatureFace
// Different feature point
surfacePoints.append(pt);
surfaceNormals.append(faceSurfaceNormal);
surfaceCount.append(1);
surfaceCounts.append(1);
}
}
}
@ -860,15 +860,15 @@ void Foam::autoSnapDriver::binFeatureFaces
DynamicList<point>& surfacePoints,
DynamicList<vector>& surfaceNormals,
DynamicList<label>& surfaceCount
DynamicList<label>& surfaceCounts
) const
{
const List<point>& pfNormals = pointFaceSurfNormals[pointI];
const List<point>& pfSurfNormals = pointFaceSurfNormals[pointI];
const List<point>& pfDisp = pointFaceDisp[pointI];
const List<point>& pfCentres = pointFaceCentres[pointI];
// Collect all different directions
forAll(pfNormals, i)
forAll(pfSurfNormals, i)
{
binFeatureFace
(
@ -879,12 +879,12 @@ void Foam::autoSnapDriver::binFeatureFaces
snapDist[pointI],
pfCentres[i],
pfNormals[i],
pfSurfNormals[i],
pfDisp[i],
surfacePoints,
surfaceNormals,
surfaceCount
surfaceCounts
);
}
}
@ -914,7 +914,7 @@ void Foam::autoSnapDriver::featureAttractionUsingReconstruction
// Collect all different directions
DynamicList<point> surfacePoints(4);
DynamicList<vector> surfaceNormals(4);
DynamicList<label> surfaceCount(4);
DynamicList<label> surfaceCounts(4);
binFeatureFaces
(
@ -931,7 +931,7 @@ void Foam::autoSnapDriver::featureAttractionUsingReconstruction
surfacePoints,
surfaceNormals,
surfaceCount
surfaceCounts
);
const point& pt = pp.localPoints()[pointI];
@ -966,11 +966,13 @@ void Foam::autoSnapDriver::featureAttractionUsingReconstruction
vector d = r.refPoint()-pt;
d -= (d&n)*n;
//- This does not help much but distorts a perfectly aligned mesh
// so disabled for now.
//// Correct for attraction to non-dominant face
//correctAttraction
//(
// surfacePoints,
// surfaceCount,
// surfaceCounts,
// r.refPoint(),
// n, // normalised normal
// pt,
@ -1813,8 +1815,8 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
}
// Reverse: from pp point to nearest feature
vectorField allPatchAttraction(pp.nPoints(), vector::zero);
List<pointConstraint> allPatchConstraints(pp.nPoints());
vectorField rawPatchAttraction(pp.nPoints(), vector::zero);
List<pointConstraint> rawPatchConstraints(pp.nPoints());
determineFeatures
(
@ -1837,15 +1839,15 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
edgeAttractors,
edgeConstraints,
// pp point to nearest feature
allPatchAttraction,
allPatchConstraints
rawPatchAttraction,
rawPatchConstraints
);
// Baffle handling
// ~~~~~~~~~~~~~~~
// Override pointAttractor, edgeAttractor, allPatchAttration etc. to
// Override pointAttractor, edgeAttractor, rawPatchAttration etc. to
// implement 'baffle' handling.
// Baffle: the mesh pp point originates from a loose standing
// baffle.
@ -1983,8 +1985,8 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
featI,
edgeAttractors,
edgeConstraints,
allPatchAttraction,
allPatchConstraints
rawPatchAttraction,
rawPatchConstraints
);
if (!nearInfo.hit())
@ -2033,8 +2035,8 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
vector::zero;
// Store for later use
allPatchAttraction[pointI] = featPt-pt;
allPatchConstraints[pointI] =
rawPatchAttraction[pointI] = featPt-pt;
rawPatchConstraints[pointI] =
pointConstraints[featI][featPointI];
if (oldPointI != -1)
@ -2053,8 +2055,8 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
edgeFeatI,
edgeAttractors,
edgeConstraints,
allPatchAttraction,
allPatchConstraints
rawPatchAttraction,
rawPatchConstraints
);
}
}
@ -2084,8 +2086,8 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
featI,
edgeAttractors,
edgeConstraints,
allPatchAttraction,
allPatchConstraints
rawPatchAttraction,
rawPatchConstraints
);
}
}
@ -2296,11 +2298,11 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
if
(
patchConstraints[pointI].first() <= 1
&& allPatchConstraints[pointI].first() > 1
&& rawPatchConstraints[pointI].first() > 1
)
{
patchAttraction[pointI] = allPatchAttraction[pointI];
patchConstraints[pointI] = allPatchConstraints[pointI];
patchAttraction[pointI] = rawPatchAttraction[pointI];
patchConstraints[pointI] = rawPatchConstraints[pointI];
if (multiPatchStr.valid())
{
@ -2434,7 +2436,7 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
// Snap edges to feature edges
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Walk existing edges and snap remaining ones (that are marked as
// feature edges in allPatchConstraints)
// feature edges in rawPatchConstraints)
stringFeatureEdges
(
@ -2444,8 +2446,8 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
pp,
snapDist,
allPatchAttraction,
allPatchConstraints,
rawPatchAttraction,
rawPatchConstraints,
patchAttraction,
patchConstraints

3
src/meshTools/Make/options
View File

@ -1,5 +1,6 @@
EXE_INC = \
-I$(LIB_SRC)/triSurface/lnInclude
-I$(LIB_SRC)/triSurface/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude
LIB_LIBS = \
-ltriSurface

494
src/meshTools/searchableSurface/searchableSurfaces.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
@ -27,12 +27,42 @@ License
#include "searchableSurfacesQueries.H"
#include "ListOps.H"
#include "Time.H"
//#include "vtkSetWriter.H"
#include "DynamicField.H"
//#include "OBJstream.H"
#include "PatchTools.H"
#include "triSurfaceMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTypeNameAndDebug(Foam::searchableSurfaces, 0);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
//- Is edge connected to triangle
bool Foam::searchableSurfaces::connected
(
const triSurface& s,
const label edgeI,
const pointIndexHit& hit
)
{
const triFace& localFace = s.localFaces()[hit.index()];
const edge& e = s.edges()[edgeI];
forAll(localFace, i)
{
if (e.otherVertex(localFace[i]) != -1)
{
return true;
}
}
return false;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct with length.
@ -378,6 +408,468 @@ Foam::pointIndexHit Foam::searchableSurfaces::facesIntersection
);
}
bool Foam::searchableSurfaces::checkClosed(const bool report) const
{
if (report)
{
Info<< "Checking for closedness." << endl;
}
bool hasError = false;
forAll(*this, surfI)
{
if (!operator[](surfI).hasVolumeType())
{
hasError = true;
if (report)
{
Info<< " " << names()[surfI]
<< " : not closed" << endl;
}
if (isA<triSurface>(operator[](surfI)))
{
const triSurface& s = dynamic_cast<const triSurface&>
(
operator[](surfI)
);
const labelListList& edgeFaces = s.edgeFaces();
label nSingleEdges = 0;
forAll(edgeFaces, edgeI)
{
if (edgeFaces[edgeI].size() == 1)
{
nSingleEdges++;
}
}
label nMultEdges = 0;
forAll(edgeFaces, edgeI)
{
if (edgeFaces[edgeI].size() > 2)
{
nMultEdges++;
}
}
if (report && (nSingleEdges != 0 || nMultEdges != 0))
{
Info<< " connected to one face : "
<< nSingleEdges << nl
<< " connected to >2 faces : "
<< nMultEdges << endl;
}
}
}
}
if (report)
{
Info<< endl;
}
return returnReduce(hasError, orOp<bool>());
}
bool Foam::searchableSurfaces::checkNormalOrientation(const bool report) const
{
if (report)
{
Info<< "Checking for normal orientation." << endl;
}
bool hasError = false;
forAll(*this, surfI)
{
if (isA<triSurface>(operator[](surfI)))
{
const triSurface& s = dynamic_cast<const triSurface&>
(
operator[](surfI)
);
labelHashSet borderEdge(s.size()/1000);
PatchTools::checkOrientation(s, false, &borderEdge);
// Colour all faces into zones using borderEdge
labelList normalZone;
label nZones = PatchTools::markZones(s, borderEdge, normalZone);
if (nZones > 1)
{
hasError = true;
if (report)
{
Info<< " " << names()[surfI]
<< " : has multiple orientation zones ("
<< nZones << ")" << endl;
}
}
}
}
if (report)
{
Info<< endl;
}
return returnReduce(hasError, orOp<bool>());
}
bool Foam::searchableSurfaces::checkSizes
(
const scalar maxRatio,
const bool report
) const
{
if (report)
{
Info<< "Checking for size." << endl;
}
bool hasError = false;
forAll(*this, i)
{
const boundBox& bb = operator[](i).bounds();
for (label j = i+1; j < size(); j++)
{
scalar ratio = bb.mag()/operator[](j).bounds().mag();
if (ratio > maxRatio || ratio < 1.0/maxRatio)
{
hasError = true;
if (report)
{
Info<< " " << names()[i]
<< " bounds differ from " << names()[j]
<< " by more than a factor 100:" << nl
<< " bounding box : " << bb << nl
<< " bounding box : " << operator[](j).bounds()
<< endl;
}
break;
}
}
}
if (report)
{
Info<< endl;
}
return returnReduce(hasError, orOp<bool>());
}
bool Foam::searchableSurfaces::checkIntersection
(
const scalar tolerance,
const autoPtr<writer<scalar> >& setWriter,
const bool report
) const
{
if (report)
{
Info<< "Checking for intersection." << endl;
}
//cpuTime timer;
bool hasError = false;
forAll(*this, i)
{
if (isA<triSurfaceMesh>(operator[](i)))
{
const triSurfaceMesh& s0 = dynamic_cast<const triSurfaceMesh&>
(
operator[](i)
);
const edgeList& edges0 = s0.edges();
const pointField& localPoints0 = s0.localPoints();
// Collect all the edge vectors
pointField start(edges0.size());
pointField end(edges0.size());
forAll(edges0, edgeI)
{
const edge& e = edges0[edgeI];
start[edgeI] = localPoints0[e[0]];
end[edgeI] = localPoints0[e[1]];
}
// Test all other surfaces for intersection
forAll(*this, j)
{
List<pointIndexHit> hits;
if (i == j)
{
// Slightly shorten the edges to prevent finding lots of
// intersections. The fast triangle intersection routine
// has problems with rays passing through a point of the
// triangle.
vectorField d
(
max(tolerance, 10*s0.tolerance())
*(end-start)
);
start += d;
end -= d;
}
operator[](j).findLineAny(start, end, hits);
label nHits = 0;
DynamicField<point> intersections(edges0.size()/100);
DynamicField<scalar> intersectionEdge(intersections.capacity());
forAll(hits, edgeI)
{
if
(
hits[edgeI].hit()
&& (i != j || !connected(s0, edgeI, hits[edgeI]))
)
{
intersections.append(hits[edgeI].hitPoint());
intersectionEdge.append(1.0*edgeI);
nHits++;
}
}
if (nHits > 0)
{
if (report)
{
Info<< " " << names()[i]
<< " intersects " << names()[j]
<< " at " << nHits
<< " locations."
<< endl;
//vtkSetWriter<scalar> setWriter;
if (setWriter.valid())
{
scalarField dist(mag(intersections));
coordSet track
(
names()[i] + '_' + names()[j],
"xyz",
intersections.xfer(),
dist
);
wordList valueSetNames(1, "edgeIndex");
List<const scalarField*> valueSets
(
1,
&intersectionEdge
);
fileName fName
(
setWriter().getFileName(track, valueSetNames)
);
Info<< " Writing intersection locations to "
<< fName << endl;
OFstream os
(
s0.searchableSurface::time().path()
/fName
);
setWriter().write
(
track,
valueSetNames,
valueSets,
os
);
}
}
hasError = true;
break;
}
}
}
}
if (report)
{
Info<< endl;
}
return returnReduce(hasError, orOp<bool>());
}
bool Foam::searchableSurfaces::checkQuality
(
const scalar minQuality,
const bool report
) const
{
if (report)
{
Info<< "Checking for triangle quality." << endl;
}
bool hasError = false;
forAll(*this, surfI)
{
if (isA<triSurface>(operator[](surfI)))
{
const triSurface& s = dynamic_cast<const triSurface&>
(
operator[](surfI)
);
label nBadTris = 0;
forAll(s, faceI)
{
const labelledTri& f = s[faceI];
scalar q = triPointRef
(
s.points()[f[0]],
s.points()[f[1]],
s.points()[f[2]]
).quality();
if (q < minQuality)
{
nBadTris++;
}
}
if (nBadTris > 0)
{
hasError = true;
if (report)
{
Info<< " " << names()[surfI]
<< " : has " << nBadTris << " bad quality triangles "
<< " (quality < " << minQuality << ")" << endl;
}
}
}
}
if (report)
{
Info<< endl;
}
return returnReduce(hasError, orOp<bool>());
}
// Check all surfaces. Return number of failures.
Foam::label Foam::searchableSurfaces::checkTopology
(
const bool report
) const
{
label noFailedChecks = 0;
if (checkClosed(report))
{
noFailedChecks++;
}
if (checkNormalOrientation(report))
{
noFailedChecks++;
}
return noFailedChecks;
}
Foam::label Foam::searchableSurfaces::checkGeometry
(
const scalar maxRatio,
const scalar tol,
const autoPtr<writer<scalar> >& setWriter,
const scalar minQuality,
const bool report
) const
{
label noFailedChecks = 0;
if (maxRatio > 0 && checkSizes(maxRatio, report))
{
noFailedChecks++;
}
if (checkIntersection(tol, setWriter, report))
{
noFailedChecks++;
}
if (checkQuality(minQuality, report))
{
noFailedChecks++;
}
return noFailedChecks;
}
void Foam::searchableSurfaces::writeStats
(
const List<wordList>& patchTypes,
Ostream& os
) const
{
Info<< "Statistics." << endl;
forAll(*this, surfI)
{
Info<< " " << names()[surfI] << ':' << endl;
const searchableSurface& s = operator[](surfI);
Info<< " type : " << s.type() << nl
<< " size : " << s.globalSize() << nl;
if (isA<triSurfaceMesh>(s))
{
const triSurfaceMesh& ts = dynamic_cast<const triSurfaceMesh&>(s);
Info<< " edges : " << ts.nEdges() << nl
<< " points : " << ts.points().size() << nl;
}
Info<< " bounds : " << s.bounds() << nl
<< " closed : " << Switch(s.hasVolumeType()) << endl;
if (patchTypes.size() && patchTypes[surfI].size() >= 1)
{
wordList unique(HashSet<word>(patchTypes[surfI]).sortedToc());
Info<< " patches : ";
forAll(unique, i)
{
Info<< unique[i];
if (i < unique.size()-1)
{
Info<< ',';
}
}
Info<< endl;
}
}
Info<< endl;
}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
const Foam::searchableSurface& Foam::searchableSurfaces::operator[]

56
src/meshTools/searchableSurface/searchableSurfaces.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
@ -37,6 +37,7 @@ SourceFiles
#include "searchableSurface.H"
#include "labelPair.H"
#include "writer.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -44,6 +45,7 @@ namespace Foam
{
// Forward declaration of classes
class triSurface;
/*---------------------------------------------------------------------------*\
Class searchableSurfaces Declaration
@ -70,6 +72,15 @@ class searchableSurfaces
// Private Member Functions
//- Is edge on face
static bool connected
(
const triSurface& s,
const label edgeI,
const pointIndexHit& hit
);
//- Disallow default bitwise copy construct
searchableSurfaces(const searchableSurfaces&);
@ -189,6 +200,49 @@ public:
) const;
// Checking
//- Are all surfaces closed and manifold
bool checkClosed(const bool report) const;
//- Are all (triangulated) surfaces consistent normal orientation
bool checkNormalOrientation(const bool report) const;
//- Are all bounding boxes of similar size
bool checkSizes(const scalar maxRatio, const bool report) const;
//- Do surfaces self-intersect or intersect others
bool checkIntersection
(
const scalar tol,
const autoPtr<writer<scalar> >&,
const bool report
) const;
//- Check triangle quality
bool checkQuality
(
const scalar minQuality,
const bool report
) const;
//- All topological checks. Return number of failed checks
label checkTopology(const bool report) const;
//- All geometric checks. Return number of failed checks
label checkGeometry
(
const scalar maxRatio,
const scalar tolerance,
const autoPtr<writer<scalar> >& setWriter,
const scalar minQuality,
const bool report
) const;
//- Write some stats
void writeStats(const List<wordList>&, Ostream&) const;
// Member Operators
//- Return const and non-const reference to searchableSurface by index.

6
src/meshTools/searchableSurface/triSurfaceMesh.C
View File

@ -625,6 +625,12 @@ Foam::triSurfaceMesh::edgeTree() const
}
Foam::scalar Foam::triSurfaceMesh::tolerance() const
{
return tolerance_;
}
const Foam::wordList& Foam::triSurfaceMesh::regions() const
{
if (regions_.empty())

3
src/meshTools/searchableSurface/triSurfaceMesh.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
@ -182,6 +182,7 @@ public:
//- Demand driven contruction of octree for boundary edges
const indexedOctree<treeDataEdge>& edgeTree() const;
scalar tolerance() const;
// searchableSurface implementation

32
src/surfMesh/surfaceFormats/obj/OBJstream.C
View File

@ -238,6 +238,38 @@ Foam::Ostream& Foam::OBJstream::write(const linePointRef& ln)
}
Foam::Ostream& Foam::OBJstream::write
(
const triPointRef& f,
const bool lines
)
{
label start = nVertices_;
write(f.a());
write(f.b());
write(f.c());
if (lines)
{
write('l');
for (int i = 0; i < 3; i++)
{
write(' ') << start+1+i;
}
write(' ') << start+1 << '\n';
}
else
{
write('f');
for (int i = 0; i < 3; i++)
{
write(' ') << start+1+i;
}
write('\n');
}
return *this;
}
Foam::Ostream& Foam::OBJstream::write
(
const face& f,

6
src/surfMesh/surfaceFormats/obj/OBJstream.H
View File

@ -39,13 +39,14 @@ SourceFiles
#include "point.H"
#include "edge.H"
#include "face.H"
#include "triPointRef.H"
#include "linePointRef.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class OBJstream Declaration
\*---------------------------------------------------------------------------*/
@ -134,6 +135,9 @@ public:
//- Write line
Ostream& write(const linePointRef&);
//- Write triangle as points with lines or filled polygon
Ostream& write(const triPointRef&, const bool lines = true);
//- Write face as points with lines or filled polygon
Ostream& write
(

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

@ -34,16 +34,56 @@ namespace Foam
defineRunTimeSelectionTable(basicThermo, fvMesh);
}
const Foam::word Foam::basicThermo::dictName("thermophysicalProperties");
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::basicThermo::basicThermo(const fvMesh& mesh)
Foam::volScalarField& Foam::basicThermo::lookupOrConstruct
(
const fvMesh& mesh,
const char* name
) const
{
if (!mesh.objectRegistry::foundObject<volScalarField>(name))
{
volScalarField* fPtr
(
new volScalarField
(
IOobject
(
name,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
);
// Transfer ownership of this object to the objectRegistry
fPtr->store(fPtr);
}
return const_cast<volScalarField&>
(
mesh.objectRegistry::lookupObject<volScalarField>(name)
);
}
Foam::basicThermo::basicThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
IOdictionary
(
IOobject
(
"thermophysicalProperties",
phasePropertyName(dictName, phaseName),
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
@ -51,24 +91,15 @@ Foam::basicThermo::basicThermo(const fvMesh& mesh)
)
),
p_
(
IOobject
(
"p",
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
),
phaseName_(phaseName),
p_(lookupOrConstruct(mesh, "p")),
T_
(
IOobject
(
"T",
phasePropertyName("T"),
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
@ -81,7 +112,7 @@ Foam::basicThermo::basicThermo(const fvMesh& mesh)
(
IOobject
(
"alpha",
phasePropertyName("alpha"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -98,14 +129,15 @@ Foam::basicThermo::basicThermo(const fvMesh& mesh)
Foam::basicThermo::basicThermo
(
const fvMesh& mesh,
const dictionary& dict
const dictionary& dict,
const word& phaseName
)
:
IOdictionary
(
IOobject
(
"thermophysicalProperties",
phasePropertyName(dictName, phaseName),
mesh.time().constant(),
mesh,
IOobject::NO_READ,
@ -114,24 +146,15 @@ Foam::basicThermo::basicThermo
dict
),
p_
(
IOobject
(
"p",
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
),
phaseName_(phaseName),
p_(lookupOrConstruct(mesh, "p")),
T_
(
IOobject
(
"T",
phasePropertyName("T"),
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
@ -144,7 +167,7 @@ Foam::basicThermo::basicThermo
(
IOobject
(
"alpha",
phasePropertyName("alpha"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -160,10 +183,11 @@ Foam::basicThermo::basicThermo
Foam::autoPtr<Foam::basicThermo> Foam::basicThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return New<basicThermo>(mesh);
return New<basicThermo>(mesh, phaseName);
}
@ -175,16 +199,52 @@ Foam::basicThermo::~basicThermo()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::basicThermo& Foam::basicThermo::lookupThermo
(
const fvPatchScalarField& pf
)
{
if (pf.db().foundObject<basicThermo>(dictName))
{
return pf.db().lookupObject<basicThermo>(dictName);
}
else
{
HashTable<const basicThermo*> thermos =
pf.db().lookupClass<basicThermo>();
for
(
HashTable<const basicThermo*>::iterator iter = thermos.begin();
iter != thermos.end();
++iter
)
{
if
(
&(iter()->he().dimensionedInternalField())
== &(pf.dimensionedInternalField())
)
{
return *iter();
}
}
}
return pf.db().lookupObject<basicThermo>(dictName);
}
void Foam::basicThermo::validate
(
const word& app,
const word& a
) const
{
if (!(he().name() == a))
if (!(he().name() == phasePropertyName(a)))
{
FatalErrorIn(app)
<< "Supported energy type is " << a
<< "Supported energy type is " << phasePropertyName(a)
<< ", thermodynamics package provides " << he().name()
<< exit(FatalError);
}
@ -197,10 +257,17 @@ void Foam::basicThermo::validate
const word& b
) const
{
if (!(he().name() == a || he().name() == b))
if
(
!(
he().name() == phasePropertyName(a)
|| he().name() == phasePropertyName(b)
)
)
{
FatalErrorIn(app)
<< "Supported energy types are " << a << " and " << b
<< "Supported energy types are " << phasePropertyName(a)
<< " and " << phasePropertyName(b)
<< ", thermodynamics package provides " << he().name()
<< exit(FatalError);
}
@ -217,14 +284,16 @@ void Foam::basicThermo::validate
if
(
!(
he().name() == a
|| he().name() == b
|| he().name() == c
he().name() == phasePropertyName(a)
|| he().name() == phasePropertyName(b)
|| he().name() == phasePropertyName(c)
)
)
{
FatalErrorIn(app)
<< "Supported energy types are " << a << ", " << b << " and " << c
<< "Supported energy types are " << phasePropertyName(a)
<< ", " << phasePropertyName(b)
<< " and " << phasePropertyName(c)
<< ", thermodynamics package provides " << he().name()
<< exit(FatalError);
}
@ -242,16 +311,18 @@ void Foam::basicThermo::validate
if
(
!(
he().name() == a
|| he().name() == b
|| he().name() == c
|| he().name() == d
he().name() == phasePropertyName(a)
|| he().name() == phasePropertyName(b)
|| he().name() == phasePropertyName(c)
|| he().name() == phasePropertyName(d)
)
)
{
FatalErrorIn(app)
<< "Supported energy types are " << a << ", " << b
<< ", " << c << " and " << d
<< "Supported energy types are " << phasePropertyName(a)
<< ", " << phasePropertyName(b)
<< ", " << phasePropertyName(c)
<< " and " << phasePropertyName(d)
<< ", thermodynamics package provides " << he().name()
<< exit(FatalError);
}

72
src/thermophysicalModels/basic/basicThermo/basicThermo.H
View File

@ -59,10 +59,14 @@ protected:
// Protected data
//- Phase-name
const word& phaseName_;
// Fields
//- Pressure [Pa]
volScalarField p_;
volScalarField& p_;
//- Temperature [K]
volScalarField T_;
@ -76,6 +80,12 @@ protected:
//- Construct as copy (not implemented)
basicThermo(const basicThermo&);
volScalarField& lookupOrConstruct
(
const fvMesh& mesh,
const char* name
) const;
public:
@ -89,18 +99,27 @@ public:
autoPtr,
basicThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Constructors
//- Construct from mesh
basicThermo(const fvMesh&);
//- Construct from mesh and phase name
basicThermo
(
const fvMesh&,
const word& phaseName
);
//- Construct from mesh
basicThermo(const fvMesh&, const dictionary&);
//- Construct from mesh, dictionary and phase name
basicThermo
(
const fvMesh&,
const dictionary&,
const word& phaseName
);
// Selectors
@ -115,14 +134,27 @@ public:
//- Generic New for each of the related thermodynamics packages
template<class Thermo>
static autoPtr<Thermo> New(const fvMesh&);
static autoPtr<Thermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Generic New for each of the related thermodynamics packages
template<class Thermo>
static autoPtr<Thermo> New(const fvMesh&, const dictionary&);
static autoPtr<Thermo> New
(
const fvMesh&,
const dictionary&,
const word& phaseName=word::null
);
//- Specialisation of the Generic New for basicThermo
static autoPtr<basicThermo> New(const fvMesh&);
static autoPtr<basicThermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Destructor
@ -131,6 +163,24 @@ public:
// Member functions
static const word dictName;
static word phasePropertyName
(
const word& name,
const word& phaseName
)
{
return name + phaseName;
}
word phasePropertyName(const word& name) const
{
return basicThermo::phasePropertyName(name, phaseName_);
}
static const basicThermo& lookupThermo(const fvPatchScalarField& pf);
//- Check that the thermodynamics package is consistent
// with energy forms supported by the application
void validate
@ -356,7 +406,7 @@ public:
) const = 0;
//- Read thermophysicalProperties dictionary
//- Read thermophysical properties dictionary
virtual bool read();
};

12
src/thermophysicalModels/basic/basicThermo/basicThermoTemplates.C
View File

@ -136,14 +136,15 @@ typename Table::iterator Foam::basicThermo::lookupThermo
template<class Thermo>
Foam::autoPtr<Thermo> Foam::basicThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
IOdictionary thermoDict
(
IOobject
(
"thermophysicalProperties",
phasePropertyName(dictName, phaseName),
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
@ -159,7 +160,7 @@ Foam::autoPtr<Thermo> Foam::basicThermo::New
Thermo::fvMeshConstructorTablePtr_
);
return autoPtr<Thermo>(cstrIter()(mesh));
return autoPtr<Thermo>(cstrIter()(mesh, phaseName));
}
@ -167,7 +168,8 @@ template<class Thermo>
Foam::autoPtr<Thermo> Foam::basicThermo::New
(
const fvMesh& mesh,
const dictionary& dict
const dictionary& dict,
const word& phaseName
)
{
typename Thermo::dictionaryConstructorTable::iterator cstrIter =
@ -177,7 +179,7 @@ Foam::autoPtr<Thermo> Foam::basicThermo::New
Thermo::dictionaryConstructorTablePtr_
);
return autoPtr<Thermo>(cstrIter()(mesh, dict));
return autoPtr<Thermo>(cstrIter()(mesh, dict, phaseName));
}

4
src/thermophysicalModels/basic/derivedFvPatchFields/energyJump/energyJump/energyJumpFvPatchScalarField.C
View File

@ -101,9 +101,7 @@ void Foam::energyJumpFvPatchScalarField::updateCoeffs()
if (this->cyclicPatch().owner())
{
const basicThermo& thermo =
db().lookupObject<basicThermo>("thermophysicalProperties");
const basicThermo& thermo = basicThermo::lookupThermo(*this);
label patchID = patch().index();
const scalarField& pp = thermo.p().boundaryField()[patchID];

4
src/thermophysicalModels/basic/derivedFvPatchFields/energyJump/energyJumpAMI/energyJumpAMIFvPatchScalarField.C
View File

@ -101,9 +101,7 @@ void Foam::energyJumpAMIFvPatchScalarField::updateCoeffs()
if (this->cyclicAMIPatch().owner())
{
const basicThermo& thermo =
db().lookupObject<basicThermo>("thermophysicalProperties");
const basicThermo& thermo = basicThermo::lookupThermo(*this);
label patchID = patch().index();
const scalarField& pp = thermo.p().boundaryField()[patchID];

7
src/thermophysicalModels/basic/derivedFvPatchFields/fixedEnergy/fixedEnergyFvPatchScalarField.C
View File

@ -97,12 +97,7 @@ void Foam::fixedEnergyFvPatchScalarField::updateCoeffs()
return;
}
const basicThermo& thermo = db().lookupObject<basicThermo>
(
"thermophysicalProperties"
);
const basicThermo& thermo = basicThermo::lookupThermo(*this);
const label patchi = patch().index();
const scalarField& pw = thermo.p().boundaryField()[patchi];

4
src/thermophysicalModels/basic/derivedFvPatchFields/gradientEnergy/gradientEnergyFvPatchScalarField.C
View File

@ -97,9 +97,7 @@ void Foam::gradientEnergyFvPatchScalarField::updateCoeffs()
return;
}
const basicThermo& thermo =
db().lookupObject<basicThermo>("thermophysicalProperties");
const basicThermo& thermo = basicThermo::lookupThermo(*this);
const label patchi = patch().index();
const scalarField& pw = thermo.p().boundaryField()[patchi];

6
src/thermophysicalModels/basic/derivedFvPatchFields/mixedEnergy/mixedEnergyFvPatchScalarField.C
View File

@ -102,11 +102,7 @@ void Foam::mixedEnergyFvPatchScalarField::updateCoeffs()
return;
}
const basicThermo& thermo = db().lookupObject<basicThermo>
(
"thermophysicalProperties"
);
const basicThermo& thermo = basicThermo::lookupThermo(*this);
const label patchi = patch().index();
const scalarField& pw = thermo.p().boundaryField()[patchi];

6
src/thermophysicalModels/basic/derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.C
View File

@ -149,11 +149,7 @@ void Foam::wallHeatTransferFvPatchScalarField::updateCoeffs()
return;
}
const basicThermo& thermo = db().lookupObject<basicThermo>
(
"thermophysicalProperties"
);
const basicThermo& thermo = basicThermo::lookupThermo(*this);
const label patchi = patch().index();
const scalarField& pw = thermo.p().boundaryField()[patchi];

18
src/thermophysicalModels/basic/fluidThermo/fluidThermo.C
View File

@ -36,16 +36,21 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::fluidThermo::fluidThermo(const fvMesh& mesh)
Foam::fluidThermo::fluidThermo(const fvMesh& mesh, const word& phaseName)
:
basicThermo(mesh)
basicThermo(mesh, phaseName)
{}
Foam::fluidThermo::fluidThermo(const fvMesh& mesh, const dictionary& dict)
Foam::fluidThermo::fluidThermo
(
const fvMesh& mesh,
const dictionary& dict,
const word& phaseName
)
:
basicThermo(mesh, dict)
basicThermo(mesh, dict, phaseName)
{}
@ -53,10 +58,11 @@ Foam::fluidThermo::fluidThermo(const fvMesh& mesh, const dictionary& dict)
Foam::autoPtr<Foam::fluidThermo> Foam::fluidThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return basicThermo::New<fluidThermo>(mesh);
return basicThermo::New<fluidThermo>(mesh, phaseName);
}

27
src/thermophysicalModels/basic/fluidThermo/fluidThermo.H
View File

@ -63,21 +63,34 @@ public:
autoPtr,
fluidThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Constructors
//- Construct from mesh
fluidThermo(const fvMesh&);
//- Construct from mesh and phase name
fluidThermo
(
const fvMesh&,
const word& phaseName
);
//- Construct from mesh
fluidThermo(const fvMesh&, const dictionary&);
//- Construct from mesh and phase name
fluidThermo
(
const fvMesh&,
const dictionary&,
const word& phaseName
);
//- Selector
static autoPtr<fluidThermo> New(const fvMesh&);
static autoPtr<fluidThermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Destructor

17
src/thermophysicalModels/basic/heThermo/heThermo.C
View File

@ -128,16 +128,20 @@ void Foam::heThermo<BasicThermo, MixtureType>::init()
template<class BasicThermo, class MixtureType>
Foam::heThermo<BasicThermo, MixtureType>::heThermo(const fvMesh& mesh)
Foam::heThermo<BasicThermo, MixtureType>::heThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
BasicThermo(mesh),
BasicThermo(mesh, phaseName),
MixtureType(*this, mesh),
he_
(
IOobject
(
MixtureType::thermoType::heName(),
BasicThermo::phasePropertyName(MixtureType::thermoType::heName()),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -156,17 +160,18 @@ template<class BasicThermo, class MixtureType>
Foam::heThermo<BasicThermo, MixtureType>::heThermo
(
const fvMesh& mesh,
const dictionary& dict
const dictionary& dict,
const word& phaseName
)
:
BasicThermo(mesh, dict),
BasicThermo(mesh, dict, phaseName),
MixtureType(*this, mesh),
he_
(
IOobject
(
MixtureType::thermoType::heName(),
BasicThermo::phasePropertyName(MixtureType::thermoType::heName()),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,

15
src/thermophysicalModels/basic/heThermo/heThermo.H
View File

@ -89,10 +89,19 @@ public:
// Constructors
//- Construct from mesh
heThermo(const fvMesh&);
heThermo
(
const fvMesh&,
const word& phaseName
);
//- Construct from mesh and dictionary
heThermo(const fvMesh&, const dictionary&);
heThermo
(
const fvMesh&,
const dictionary&,
const word& phaseName
);
//- Destructor
@ -284,7 +293,7 @@ public:
) const;
//- Read thermophysicalProperties dictionary
//- Read thermophysical properties dictionary
virtual bool read();
};

8
src/thermophysicalModels/basic/psiThermo/hePsiThermo.C
View File

@ -102,9 +102,13 @@ void Foam::hePsiThermo<BasicPsiThermo, MixtureType>::calculate()
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class BasicPsiThermo, class MixtureType>
Foam::hePsiThermo<BasicPsiThermo, MixtureType>::hePsiThermo(const fvMesh& mesh)
Foam::hePsiThermo<BasicPsiThermo, MixtureType>::hePsiThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
heThermo<BasicPsiThermo, MixtureType>(mesh)
heThermo<BasicPsiThermo, MixtureType>(mesh, phaseName)
{
calculate();

8
src/thermophysicalModels/basic/psiThermo/hePsiThermo.H
View File

@ -68,8 +68,12 @@ public:
// Constructors
//- Construct from mesh
hePsiThermo(const fvMesh&);
//- Construct from mesh and phase name
hePsiThermo
(
const fvMesh&,
const word& phaseName
);
//- Destructor

13
src/thermophysicalModels/basic/psiThermo/psiThermo.C
View File

@ -36,15 +36,15 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::psiThermo::psiThermo(const fvMesh& mesh)
Foam::psiThermo::psiThermo(const fvMesh& mesh, const word& phaseName)
:
fluidThermo(mesh),
fluidThermo(mesh, phaseName),
psi_
(
IOobject
(
"psi",
phasePropertyName("psi"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -58,7 +58,7 @@ Foam::psiThermo::psiThermo(const fvMesh& mesh)
(
IOobject
(
"mu",
phasePropertyName("mu"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -74,10 +74,11 @@ Foam::psiThermo::psiThermo(const fvMesh& mesh)
Foam::autoPtr<Foam::psiThermo> Foam::psiThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return basicThermo::New<psiThermo>(mesh);
return basicThermo::New<psiThermo>(mesh, phaseName);
}

18
src/thermophysicalModels/basic/psiThermo/psiThermo.H
View File

@ -81,19 +81,27 @@ public:
autoPtr,
psiThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Constructors
//- Construct from mesh
psiThermo(const fvMesh&);
//- Construct from mesh and phase name
psiThermo
(
const fvMesh&,
const word& phaseName
);
//- Selector
static autoPtr<psiThermo> New(const fvMesh&);
static autoPtr<psiThermo> New
(
const fvMesh& mesh,
const word& phaseName=word::null
);
//- Destructor

8
src/thermophysicalModels/basic/rhoThermo/heRhoThermo.C
View File

@ -107,9 +107,13 @@ void Foam::heRhoThermo<BasicPsiThermo, MixtureType>::calculate()
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class BasicPsiThermo, class MixtureType>
Foam::heRhoThermo<BasicPsiThermo, MixtureType>::heRhoThermo(const fvMesh& mesh)
Foam::heRhoThermo<BasicPsiThermo, MixtureType>::heRhoThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
heThermo<BasicPsiThermo, MixtureType>(mesh)
heThermo<BasicPsiThermo, MixtureType>(mesh, phaseName)
{
calculate();
}

8
src/thermophysicalModels/basic/rhoThermo/heRhoThermo.H
View File

@ -69,8 +69,12 @@ public:
// Constructors
//- Construct from mesh
heRhoThermo(const fvMesh&);
//- Construct from mesh and phase name
heRhoThermo
(
const fvMesh&,
const word& phaseName
);
//- Destructor

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

@ -36,14 +36,14 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::rhoThermo::rhoThermo(const fvMesh& mesh)
Foam::rhoThermo::rhoThermo(const fvMesh& mesh, const word& phaseName)
:
fluidThermo(mesh),
fluidThermo(mesh, phaseName),
rho_
(
IOobject
(
"rhoThermo",
phasePropertyName("rhoThermo"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -57,7 +57,7 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh)
(
IOobject
(
"psi",
phasePropertyName("psi"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -71,7 +71,7 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh)
(
IOobject
(
"mu",
phasePropertyName("mu"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -83,14 +83,19 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh)
{}
Foam::rhoThermo::rhoThermo(const fvMesh& mesh, const dictionary& dict)
Foam::rhoThermo::rhoThermo
(
const fvMesh& mesh,
const dictionary& dict,
const word& phaseName
)
:
fluidThermo(mesh, dict),
fluidThermo(mesh, dict, phaseName),
rho_
(
IOobject
(
"rhoThermo",
phasePropertyName("rhoThermo"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -104,7 +109,7 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh, const dictionary& dict)
(
IOobject
(
"psi",
phasePropertyName("psi"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -118,7 +123,7 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh, const dictionary& dict)
(
IOobject
(
"mu",
phasePropertyName("mu"),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
@ -134,10 +139,11 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh, const dictionary& dict)
Foam::autoPtr<Foam::rhoThermo> Foam::rhoThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return basicThermo::New<rhoThermo>(mesh);
return basicThermo::New<rhoThermo>(mesh, phaseName);
}

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

@ -85,22 +85,35 @@ public:
autoPtr,
rhoThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Constructors
//- Construct from mesh
rhoThermo(const fvMesh&);
//- Construct from mesh and phase name
rhoThermo
(
const fvMesh&,
const word& phaseName
);
//- Construct from mesh
rhoThermo(const fvMesh&, const dictionary&);
//- Construct from mesh, dictionary and phase name
rhoThermo
(
const fvMesh&,
const dictionary&,
const word& phaseName
);
//- Selector
static autoPtr<rhoThermo> New(const fvMesh&);
static autoPtr<rhoThermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Destructor

13
src/thermophysicalModels/reactionThermo/psiReactionThermo/psiReactionThermo.C
View File

@ -36,9 +36,13 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::psiReactionThermo::psiReactionThermo(const fvMesh& mesh)
Foam::psiReactionThermo::psiReactionThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
psiThermo(mesh)
psiThermo(mesh, phaseName)
{}
@ -46,10 +50,11 @@ Foam::psiReactionThermo::psiReactionThermo(const fvMesh& mesh)
Foam::autoPtr<Foam::psiReactionThermo> Foam::psiReactionThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return basicThermo::New<psiReactionThermo>(mesh);
return basicThermo::New<psiReactionThermo>(mesh, phaseName);
}

18
src/thermophysicalModels/reactionThermo/psiReactionThermo/psiReactionThermo.H
View File

@ -66,21 +66,29 @@ public:
autoPtr,
psiReactionThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Constructors
//- Construct from dictionary and mesh
psiReactionThermo(const fvMesh&);
//- Construct from mesh and phase name
psiReactionThermo
(
const fvMesh&,
const word& phaseName
);
// Selectors
//- Standard selection based on fvMesh
static autoPtr<psiReactionThermo> New(const fvMesh&);
static autoPtr<psiReactionThermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Destructor

5
src/thermophysicalModels/reactionThermo/psiuReactionThermo/heheuPsiThermo.C
View File

@ -121,10 +121,11 @@ void Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::calculate()
template<class BasicPsiThermo, class MixtureType>
Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::heheuPsiThermo
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
:
heThermo<psiuReactionThermo, MixtureType>(mesh),
heThermo<psiuReactionThermo, MixtureType>(mesh, phaseName),
Tu_
(
IOobject

8
src/thermophysicalModels/reactionThermo/psiuReactionThermo/heheuPsiThermo.H
View File

@ -76,8 +76,12 @@ public:
// Constructors
//- Construct from mesh
heheuPsiThermo(const fvMesh&);
//- Construct from mesh and phase name
heheuPsiThermo
(
const fvMesh&,
const word& phaseName
);
//- Destructor

13
src/thermophysicalModels/reactionThermo/psiuReactionThermo/psiuReactionThermo.C
View File

@ -100,9 +100,13 @@ void psiuReactionThermo::heuBoundaryCorrection(volScalarField& heu)
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
psiuReactionThermo::psiuReactionThermo(const fvMesh& mesh)
psiuReactionThermo::psiuReactionThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
psiReactionThermo(mesh)
psiReactionThermo(mesh, phaseName)
{}
@ -110,10 +114,11 @@ psiuReactionThermo::psiuReactionThermo(const fvMesh& mesh)
Foam::autoPtr<Foam::psiuReactionThermo> Foam::psiuReactionThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return basicThermo::New<psiuReactionThermo>(mesh);
return basicThermo::New<psiuReactionThermo>(mesh, phaseName);
}

18
src/thermophysicalModels/reactionThermo/psiuReactionThermo/psiuReactionThermo.H
View File

@ -73,20 +73,28 @@ public:
autoPtr,
psiuReactionThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Constructors
//- Construct from dictionary and mesh
psiuReactionThermo(const fvMesh&);
//- Construct from mesh and phase name
psiuReactionThermo
(
const fvMesh&,
const word& phaseName
);
// Selectors
static autoPtr<psiuReactionThermo> New(const fvMesh&);
static autoPtr<psiuReactionThermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Destructor

13
src/thermophysicalModels/reactionThermo/rhoReactionThermo/rhoReactionThermo.C
View File

@ -36,9 +36,13 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::rhoReactionThermo::rhoReactionThermo(const fvMesh& mesh)
Foam::rhoReactionThermo::rhoReactionThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
rhoThermo(mesh)
rhoThermo(mesh, phaseName)
{}
@ -46,10 +50,11 @@ Foam::rhoReactionThermo::rhoReactionThermo(const fvMesh& mesh)
Foam::autoPtr<Foam::rhoReactionThermo> Foam::rhoReactionThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return basicThermo::New<rhoReactionThermo>(mesh);
return basicThermo::New<rhoReactionThermo>(mesh, phaseName);
}

18
src/thermophysicalModels/reactionThermo/rhoReactionThermo/rhoReactionThermo.H
View File

@ -66,21 +66,29 @@ public:
autoPtr,
rhoReactionThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Constructors
//- Construct from dictionary and mesh
rhoReactionThermo(const fvMesh&);
//- Construct from mesh and phase name
rhoReactionThermo
(
const fvMesh&,
const word& phaseName
);
// Selectors
//- Standard selection based on fvMesh
static autoPtr<rhoReactionThermo> New(const fvMesh&);
static autoPtr<rhoReactionThermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Destructor

23
src/thermophysicalModels/solidThermo/solidReactionThermo/solidReactionThermo.C
View File

@ -38,19 +38,24 @@ namespace Foam
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::solidReactionThermo::solidReactionThermo(const fvMesh& mesh)
Foam::solidReactionThermo::solidReactionThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
solidThermo(mesh)
solidThermo(mesh, phaseName)
{}
Foam::solidReactionThermo::solidReactionThermo
(
const fvMesh& mesh,
const dictionary& dict
const dictionary& dict,
const word& phaseName
)
:
solidThermo(mesh, dict)
solidThermo(mesh, dict, phaseName)
{}
@ -58,20 +63,22 @@ Foam::solidReactionThermo::solidReactionThermo
Foam::autoPtr<Foam::solidReactionThermo> Foam::solidReactionThermo::New
(
const fvMesh& mesh
const fvMesh& mesh,
const word& phaseName
)
{
return basicThermo::New<solidReactionThermo>(mesh);
return basicThermo::New<solidReactionThermo>(mesh, phaseName);
}
Foam::autoPtr<Foam::solidReactionThermo> Foam::solidReactionThermo::New
(
const fvMesh& mesh,
const dictionary& dict
const dictionary& dict,
const word& phaseName
)
{
return basicThermo::New<solidReactionThermo>(mesh, dict);
return basicThermo::New<solidReactionThermo>(mesh, dict, phaseName);
}

35
src/thermophysicalModels/solidThermo/solidReactionThermo/solidReactionThermo.H
View File

@ -67,8 +67,8 @@ public:
autoPtr,
solidReactionThermo,
fvMesh,
(const fvMesh& mesh),
(mesh)
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
);
// Declare run-time constructor selection tables
@ -77,31 +77,46 @@ public:
autoPtr,
solidReactionThermo,
dictionary,
(const fvMesh& mesh, const dictionary& dict),
(mesh, dict)
(const fvMesh& mesh, const dictionary& dict, const word& phaseName),
(mesh, dict, phaseName)
);
// Constructors
//- Construct from mesh
solidReactionThermo(const fvMesh&);
//- Construct from mesh and phase name
solidReactionThermo
(
const fvMesh&,
const word& phaseName
);
//- Construct from dictionary and mesh
solidReactionThermo(const fvMesh&, const dictionary&);
//- Construct from mesh, dictionary and phase name
solidReactionThermo
(
const fvMesh&,
const dictionary&,
const word& phaseName
);
// Selectors
//- Standard selection based on fvMesh
static autoPtr<solidReactionThermo> New(const fvMesh&);
static autoPtr<solidReactionThermo> New
(
const fvMesh&,
const word& phaseName=word::null
);
//- Standard selection based on fvMesh amd dictionary
static autoPtr<solidReactionThermo> New
(
const fvMesh&,
const dictionary&
const dictionary&,
const word& phaseName=word::null
);
//- Destructor
virtual ~solidReactionThermo();

17
src/thermophysicalModels/solidThermo/solidThermo/heSolidThermo.C
View File

@ -127,9 +127,13 @@ void Foam::heSolidThermo<BasicSolidThermo, MixtureType>::calculate()
template<class BasicSolidThermo, class MixtureType>
Foam::heSolidThermo<BasicSolidThermo, MixtureType>::
heSolidThermo(const fvMesh& mesh)
heSolidThermo
(
const fvMesh& mesh,
const word& phaseName
)
:
heThermo<BasicSolidThermo, MixtureType>(mesh)
heThermo<BasicSolidThermo, MixtureType>(mesh, phaseName)
{
calculate();
}
@ -137,9 +141,14 @@ heSolidThermo(const fvMesh& mesh)
template<class BasicSolidThermo, class MixtureType>
Foam::heSolidThermo<BasicSolidThermo, MixtureType>::
heSolidThermo(const fvMesh& mesh, const dictionary& dict)
heSolidThermo
(
const fvMesh& mesh,
const dictionary& dict,
const word& phaseName
)
:
heThermo<BasicSolidThermo, MixtureType>(mesh, dict)
heThermo<BasicSolidThermo, MixtureType>(mesh, dict, phaseName)
{
calculate();
}

17
src/thermophysicalModels/solidThermo/solidThermo/heSolidThermo.H
View File

@ -68,11 +68,20 @@ public:
// Constructors
//- Construct from mesh
heSolidThermo(const fvMesh&);
//- Construct from mesh and phase name
heSolidThermo
(
const fvMesh&,
const word& phaseName
);
//- Construct from mesh and dictionary
heSolidThermo(const fvMesh&, const dictionary&);
//- Construct from mesh, dictionary and phase name
heSolidThermo
(
const fvMesh&,
const dictionary&,
const word& phaseName
);
//- Destructor

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