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

major clean-up

Browse Source
This commit is contained in:
andy
2009-02-04 09:46:26 +00:00
parent 6d3a272372
commit 61e1c0c1ea
17 changed files with 87 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files
View File

@ -7,6 +7,8 @@ derivedFvPatchFields/solidWallHeatFluxTemperatureCoupled/solidWallHeatFluxTemper
derivedFvPatchFields/solidWallTemperatureCoupled/solidWallTemperatureCoupledFvPatchScalarField.C
derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C
fluid/compressibleCourantNo.C
chtMultiRegionFoam.C
EXE = $(FOAM_APPBIN)/chtMultiRegionFoam

11
applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C
View File

@ -36,16 +36,10 @@ Description
#include "turbulenceModel.H"
#include "fixedGradientFvPatchFields.H"
#include "regionProperties.H"
#include "compressibleCourantNo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "solveContinuityEquation.C"
#include "solveMomentumEquation.C"
#include "compressibleContinuityErrors.C"
#include "solvePressureDifferenceEquation.C"
#include "solveEnthalpyEquation.C"
#include "compressibleCourantNo.C"
int main(int argc, char *argv[])
{
@ -58,7 +52,6 @@ int main(int argc, char *argv[])
# include "createSolidMeshes.H"
# include "createFluidFields.H"
# include "createSolidFields.H"
# include "initContinuityErrs.H"
@ -89,6 +82,7 @@ int main(int argc, char *argv[])
{
Info<< "\nSolving for fluid region "
<< fluidRegions[i].name() << endl;
# include "setRegionFluidFields.H"
# include "readFluidMultiRegionPISOControls.H"
# include "solveFluid.H"
}
@ -97,6 +91,7 @@ int main(int argc, char *argv[])
{
Info<< "\nSolving for solid region "
<< solidRegions[i].name() << endl;
# include "setRegionSolidFields.H"
# include "readSolidMultiRegionPISOControls.H"
# include "solveSolid.H"
}

20
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/UEqn.H
View File

@ -1,10 +1,14 @@
tmp<fvVectorMatrix> UEqn = solveMomentumEquation
// Solve the Momentum equation
tmp<fvVectorMatrix> UEqn
(
momentumPredictor,
Uf[i],
rhof[i],
phif[i],
pdf[i],
ghf[i],
turb[i]
fvm::ddt(rho, U)
+ fvm::div(phi, U)
+ turb.divDevRhoReff(U)
);
UEqn().relax();
if (momentumPredictor)
{
solve(UEqn() == -fvc::grad(pd) - fvc::grad(rho)*gh);
}

58
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleContinuityErrors.C
View File

@ -1,58 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Continuity errors for fluid meshes
\*---------------------------------------------------------------------------*/
void compressibleContinuityErrors
(
scalar& cumulativeContErr,
const volScalarField& rho,
const basicThermo& thermo
)
{
dimensionedScalar totalMass = fvc::domainIntegrate(rho);
scalar sumLocalContErr =
(
fvc::domainIntegrate(mag(rho - thermo.rho()))/totalMass
).value();
scalar globalContErr =
(
fvc::domainIntegrate(rho - thermo.rho())/totalMass
).value();
cumulativeContErr += globalContErr;
const word& regionName = rho.mesh().name();
Info<< "time step continuity errors (" << regionName << ")"
<< ": sum local = " << sumLocalContErr
<< ", global = " << globalContErr
<< ", cumulative = " << cumulativeContErr
<< endl;
}

11
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleCourantNo.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\ / A nd | Copyright (C) 1991-2008 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,13 +22,12 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Calculates and outputs the mean and maximum Courant Numbers for the fluid
regions
\*---------------------------------------------------------------------------*/
scalar compressibleCourantNo
#include "compressibleCourantNo.H"
#include "fvc.H"
Foam::scalar Foam::compressibleCourantNo
(
const fvMesh& mesh,
const Time& runTime,

6
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
View File

@ -4,7 +4,7 @@
PtrList<volScalarField> Kf(fluidRegions.size());
PtrList<volVectorField> Uf(fluidRegions.size());
PtrList<surfaceScalarField> phif(fluidRegions.size());
PtrList<compressible::turbulenceModel> turb(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> DpDtf(fluidRegions.size());
PtrList<volScalarField> ghf(fluidRegions.size());
PtrList<volScalarField> pdf(fluidRegions.size());
@ -123,8 +123,8 @@
)
);
Info<< " Adding to turb\n" << endl;
turb.set
Info<< " Adding to turbulence\n" << endl;
turbulence.set
(
i,
autoPtr<compressible::turbulenceModel>

20
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/hEqn.H
View File

@ -1,9 +1,17 @@
solveEnthalpyEquation
{
tmp<fvScalarMatrix> hEqn
(
rhof[i],
DpDtf[i],
phif[i],
turb[i],
thermof[i]
fvm::ddt(rho, h)
+ fvm::div(phi, h)
- fvm::laplacian(turb.alphaEff(), h)
==
DpDt
);
hEqn().relax();
hEqn().solve();
thermo.correct();
Info<< "Min/max T:" << min(thermo.T()) << ' ' << max(thermo.T())
<< endl;
}

78
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/pEqn.H
View File

@ -1,60 +1,70 @@
{
bool closedVolume = false;
rhof[i] = thermof[i].rho();
rho = thermo.rho();
volScalarField rUA = 1.0/UEqn().A();
Uf[i] = rUA*UEqn().H();
U = rUA*UEqn().H();
phif[i] =
fvc::interpolate(rhof[i])
phi =
fvc::interpolate(rho)
*(
(fvc::interpolate(Uf[i]) & fluidRegions[i].Sf())
+ fvc::ddtPhiCorr(rUA, rhof[i], Uf[i], phif[i])
(fvc::interpolate(U) & mesh.Sf())
+ fvc::ddtPhiCorr(rUA, rho, U, phi)
)
- fvc::interpolate(rhof[i]*rUA*ghf[i])
*fvc::snGrad(rhof[i])
*fluidRegions[i].magSf();
- fvc::interpolate(rho*rUA*gh)*fvc::snGrad(rho)*mesh.magSf();
// Solve pressure difference
# include "pdEqn.H"
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pdEqn
(
fvc::ddt(rho)
+ fvc::div(phi)
- fvm::laplacian(rho*rUA, pd)
);
if (corr == nCorr-1 && nonOrth == nNonOrthCorr)
{
pdEqn.solve(mesh.solver(pd.name() + "Final"));
}
else
{
pdEqn.solve(mesh.solver(pd.name()));
}
if (nonOrth == nNonOrthCorr)
{
phi += pdEqn.flux();
}
}
// Update pressure field (including bc)
thermo.p() == pd + rho*gh + pRef;
DpDt = fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);
// Solve continuity
# include "rhoEqn.H"
// Update pressure field (including bc)
thermof[i].p() == pdf[i] + rhof[i]*ghf[i] + pRef;
DpDtf[i] = fvc::DDt
(
surfaceScalarField("phiU", phif[i]/fvc::interpolate(rhof[i])),
thermof[i].p()
);
// Update continuity errors
compressibleContinuityErrors(cumulativeContErr, rhof[i], thermof[i]);
# include "compressibleContinuityErrors.H"
// Correct velocity field
Uf[i] -= rUA*(fvc::grad(pdf[i]) + fvc::grad(rhof[i])*ghf[i]);
Uf[i].correctBoundaryConditions();
U -= rUA*(fvc::grad(pd) + fvc::grad(rho)*gh);
U.correctBoundaryConditions();
// For closed-volume cases adjust the pressure and density levels
// to obey overall mass continuity
if (closedVolume)
{
thermof[i].p() +=
thermo.p() +=
(
dimensionedScalar
(
"massIni",
dimMass,
initialMassf[i]
)
- fvc::domainIntegrate(thermof[i].psi()*thermof[i].p())
)/fvc::domainIntegrate(thermof[i].psi());
pdf[i] == thermof[i].p() - (rhof[i]*ghf[i] + pRef);
rhof[i] = thermof[i].rho();
dimensionedScalar("massIni", dimMass, initialMassf[i])
- fvc::domainIntegrate(thermo.psi()*thermo.p())
)/fvc::domainIntegrate(thermo.psi());
pd == thermo.p() - (rho*gh + pRef);
rho = thermo.rho();
}
// Update thermal conductivity
Kf[i] = thermof[i].Cp()*turb[i].alphaEff();
K = thermo.Cp()*turb.alphaEff();
}

14
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/pdEqn.H
View File

@ -1,14 +0,0 @@
solvePressureDifferenceEquation
(
corr,
nCorr,
nNonOrthCorr,
closedVolume,
pdf[i],
pRef,
rhof[i],
thermof[i].psi(),
rUA,
ghf[i],
phif[i]
);

2
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/rhoEqn.H
View File

@ -1 +1 @@
solveContinuityEquation(rhof[i], phif[i]);
solve(fvm::ddt(rho) + fvc::div(phi));

15
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/setInitialDeltaT.H
View File

@ -1,15 +0,0 @@
if (adjustTimeStep)
{
if (CoNum > SMALL)
{
runTime.setDeltaT
(
min
(
maxCo*runTime.deltaT().value()/CoNum,
maxDeltaT
)
);
}
}

37
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/solveContinuityEquation.C
View File

@ -1,37 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Solve continuity equation
\*---------------------------------------------------------------------------*/
void solveContinuityEquation
(
volScalarField& rho,
const surfaceScalarField& phi
)
{
solve(fvm::ddt(rho) + fvc::div(phi));
}

56
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/solveEnthalpyEquation.C
View File

@ -1,56 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Solve enthalpy equation
\*---------------------------------------------------------------------------*/
void solveEnthalpyEquation
(
const volScalarField& rho,
const volScalarField& DpDt,
const surfaceScalarField& phi,
const compressible::turbulenceModel& turb,
basicThermo& thermo
)
{
volScalarField& h = thermo.h();
tmp<fvScalarMatrix> hEqn
(
fvm::ddt(rho, h)
+ fvm::div(phi, h)
- fvm::laplacian(turb.alphaEff(), h)
==
DpDt
);
hEqn().relax();
hEqn().solve();
thermo.correct();
Info<< "Min/max T:" << min(thermo.T()) << ' ' << max(thermo.T())
<< endl;
}

2
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/solveFluid.H
View File

@ -12,4 +12,4 @@
# include "pEqn.H"
}
}
turb[i].correct();
turb.correct();

57
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/solveMomentumEquation.C
View File

@ -1,57 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Solve momentum equation and return matrix for use in pressure equation
\*---------------------------------------------------------------------------*/
tmp<fvVectorMatrix> solveMomentumEquation
(
const bool momentumPredictor,
volVectorField& U,
const volScalarField& rho,
const surfaceScalarField& phi,
const volScalarField& pd,
const volScalarField& gh,
const compressible::turbulenceModel& turb
)
{
// Solve the Momentum equation
tmp<fvVectorMatrix> UEqn
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
+ turb.divDevRhoReff(U)
);
UEqn().relax();
if (momentumPredictor)
{
solve(UEqn() == -fvc::grad(pd) - fvc::grad(rho)*gh);
}
return UEqn;
}

73
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/solvePressureDifferenceEquation.C
View File

@ -1,73 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Solve pressure difference equation
\*---------------------------------------------------------------------------*/
void solvePressureDifferenceEquation
(
const label corr,
const label nCorr,
const label nNonOrthCorr,
bool& closedVolume,
volScalarField& pd,
const dimensionedScalar& pRef,
const volScalarField& rho,
const volScalarField& psi,
const volScalarField& rUA,
const volScalarField& gh,
surfaceScalarField& phi
)
{
closedVolume = pd.needReference();
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pdEqn
(
fvm::ddt(psi, pd)
+ fvc::ddt(psi)*pRef
+ fvc::ddt(psi, rho)*gh
+ fvc::div(phi)
- fvm::laplacian(rho*rUA, pd)
);
//pdEqn.solve();
if (corr == nCorr-1 && nonOrth == nNonOrthCorr)
{
pdEqn.solve(pd.mesh().solver(pd.name() + "Final"));
}
else
{
pdEqn.solve(pd.mesh().solver(pd.name()));
}
if (nonOrth == nNonOrthCorr)
{
phi += pdEqn.flux();
}
}
}

5
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solveSolid.H
View File

@ -3,10 +3,9 @@
{
solve
(
fvm::ddt(rhosCps[i], Ts[i]) - fvm::laplacian(Ks[i], Ts[i])
fvm::ddt(rho*cp, T) - fvm::laplacian(K, T)
);
}
Info<< "Min/max T:" << min(Ts[i]) << ' ' << max(Ts[i])
<< endl;
Info<< "Min/max T:" << min(T) << ' ' << max(T) << endl;
}