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

Merge branch 'master' into particleInteractions

Browse Source
This commit is contained in:
graham
2009-12-06 12:14:03 +00:00
parent 6cbf1c9425 f23e3eb3ea
commit 9f702d722d
859 changed files with 62927 additions and 10507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -51,7 +51,9 @@ doc/[Dd]oxygen/latex
doc/[Dd]oxygen/man
# generated files in the main directory (e.g. ReleaseNotes-?.?.html)
# and in the doc directory
/*.html
/doc/*.html
# source packages - anywhere
*.tar.bz2

17
README
View File

@ -2,7 +2,7 @@
#
#+TITLE: OpenFOAM README for version 1.6
#+AUTHOR: OpenCFD Ltd.
#+DATE: July 2009
#+DATE: November 2009
#+LINK: http://www.opencfd.co.uk
#+OPTIONS: author:nil ^:{}
@ -99,7 +99,7 @@
and a csh/tcsh example:
+ setenv FOAM_INST_DIR /data/app/OpenFOAM
+ foamDotFile=$FOAM_INST_DIR/OpenFOAM-1.6/etc/bashrc
+ foamDotFile=$FOAM_INST_DIR/OpenFOAM-1.6/etc/cshrc
+ if ( -f $foamDotFile ) source $foamDotFile
The value set in '$FOAM_INST_DIR' will be used to locate the remaining parts
@ -168,9 +168,9 @@
+ rm -rf paraview-3.6.1/platforms
+ ./makeParaView
The PV3FoamReader module is an OpenFOAM utility that can be compiled in the
usual manner as follows:
+ cd $FOAM_UTILITIES/postProcessing/graphics/PV3FoamReader
The PV3blockMeshReader and the PV3FoamReader ParaView plugins are compiled
as usual for OpenFOAM utilities:
+ cd $FOAM_UTILITIES/postProcessing/graphics/PV3Readers/
+ ./Allwclean
+ ./Allwmake
@ -180,14 +180,15 @@
downloads a supported version of Qt /e.g./ 4.3.5 as described in the section
on "Qt". The user should unpack the source pack in the $WM_THIRD_PARTY_DIR.
Then the user can build Qt by executing from within $WM_THIRD_PARTY_DIR:
+ makeQt
+ ./makeQt
The user should then compile ParaView using the local version of Qt by
executing makeParaView with the -qmake option, giving the full path of the
newly built qmake as an argument:
+ makeParaView -qmake <path_to_qmake>
+ ./makeParaView -qmake <path_to_qmake>
The user must then recompile the PV3FoamReader module as normal (see above).
The user must then recompile the PV3blockMeshReader and the
PV3FoamReader plugins as usual (see above).
* Documentation
http://www.OpenFOAM.org/doc

4
applications/solvers/combustion/dieselEngineFoam/dieselEngineFoam.C
View File

@ -64,7 +64,7 @@ int main(int argc, char *argv[])
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info << "\nStarting time loop\n" << endl;
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{
@ -85,7 +85,7 @@ int main(int argc, char *argv[])
dieselSpray.evolve();
Info << "Solving chemistry" << endl;
Info<< "Solving chemistry" << endl;
chemistry.solve
(

6
applications/solvers/combustion/dieselFoam/dieselFoam.C
View File

@ -61,7 +61,7 @@ int main(int argc, char *argv[])
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info << "\nStarting time loop\n" << endl;
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{
@ -72,11 +72,11 @@ int main(int argc, char *argv[])
runTime++;
Info<< "Time = " << runTime.timeName() << nl << endl;
Info << "Evolving Spray" << endl;
Info<< "Evolving Spray" << endl;
dieselSpray.evolve();
Info << "Solving chemistry" << endl;
Info<< "Solving chemistry" << endl;
chemistry.solve
(

2
applications/solvers/combustion/engineFoam/engineFoam.C
View File

@ -78,7 +78,7 @@ int main(int argc, char *argv[])
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info << "\nStarting time loop\n" << endl;
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{

2
applications/solvers/combustion/reactingFoam/chemistry.H
View File

@ -1,5 +1,5 @@
{
Info << "Solving chemistry" << endl;
Info<< "Solving chemistry" << endl;
chemistry.solve
(

2
applications/solvers/combustion/reactingFoam/reactingFoam.C
View File

@ -54,7 +54,7 @@ int main(int argc, char *argv[])
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info << "\nStarting time loop\n" << endl;
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{

2
applications/solvers/combustion/rhoReactingFoam/chemistry.H
View File

@ -1,5 +1,5 @@
{
Info << "Solving chemistry" << endl;
Info<< "Solving chemistry" << endl;
chemistry.solve
(

2
applications/solvers/combustion/rhoReactingFoam/rhoReactingFoam.C
View File

@ -55,7 +55,7 @@ int main(int argc, char *argv[])
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info << "\nStarting time loop\n" << endl;
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{

4
applications/solvers/compressible/rhoCentralFoam/BCs/U/maxwellSlipUFvPatchVectorField.C
View File

@ -155,7 +155,7 @@ void maxwellSlipUFvPatchVectorField::updateCoeffs()
refValue() = Uwall_;
if(thermalCreep_)
if (thermalCreep_)
{
const volScalarField& vsfT =
this->db().objectRegistry::lookupObject<volScalarField>("T");
@ -167,7 +167,7 @@ void maxwellSlipUFvPatchVectorField::updateCoeffs()
refValue() -= 3.0*pnu/(4.0*pT)*transform(I - n*n, gradpT);
}
if(curvature_)
if (curvature_)
{
const fvPatchTensorField& ptauMC =
patch().lookupPatchField<volTensorField, tensor>("tauMC");

2
applications/solvers/compressible/rhoSimpleFoam/pEqn.H
View File

@ -27,7 +27,7 @@ if (transonic)
pEqn.setReference(pRefCell, pRefValue);
// retain the residual from the first iteration
// Retain the residual from the first iteration
if (nonOrth == 0)
{
eqnResidual = pEqn.solve().initialResidual();

3
applications/solvers/compressible/rhoSimplecFoam/Make/files Normal file
View File

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

14
applications/solvers/compressible/rhoSimplecFoam/Make/options Normal file
View File

@ -0,0 +1,14 @@
EXE_INC = \
-I../rhoSimpleFoam \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/turbulenceModels \
-I$(LIB_SRC)/turbulenceModels/compressible/RAS/RASModel \
-I$(LIB_SRC)/finiteVolume/cfdTools \
-I$(LIB_SRC)/finiteVolume/lnInclude
EXE_LIBS = \
-lbasicThermophysicalModels \
-lspecie \
-lcompressibleRASModels \
-lfiniteVolume \
-lmeshTools

17
applications/solvers/compressible/rhoSimplecFoam/UEqn.H Normal file
View File

@ -0,0 +1,17 @@
// Solve the Momentum equation
tmp<fvVectorMatrix> UEqn
(
fvm::div(phi, U)
- fvm::Sp(fvc::div(phi), U)
+ turbulence->divDevRhoReff(U)
);
UEqn().relax();
eqnResidual = solve
(
UEqn() == -fvc::grad(p)
).initialResidual();
maxResidual = max(eqnResidual, maxResidual);

63
applications/solvers/compressible/rhoSimplecFoam/createFields.H Normal file
View File

@ -0,0 +1,63 @@
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<basicPsiThermo> pThermo
(
basicPsiThermo::New(mesh)
);
basicPsiThermo& thermo = pThermo();
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
thermo.rho()
);
volScalarField& p = thermo.p();
volScalarField& h = thermo.h();
const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, mesh.solutionDict().subDict("SIMPLE"), pRefCell, pRefValue);
dimensionedScalar pMin
(
mesh.solutionDict().subDict("SIMPLE").lookup("pMin")
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
U,
phi,
thermo
)
);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);

29
applications/solvers/compressible/rhoSimplecFoam/hEqn.H Normal file
View File

@ -0,0 +1,29 @@
{
fvScalarMatrix hEqn
(
fvm::div(phi, h)
- fvm::Sp(fvc::div(phi), h)
- fvm::laplacian(turbulence->alphaEff(), h)
==
fvc::div(phi/fvc::interpolate(rho)*fvc::interpolate(p, "div(U,p)"))
- p*fvc::div(phi/fvc::interpolate(rho))
);
hEqn.relax();
eqnResidual = hEqn.solve().initialResidual();
maxResidual = max(eqnResidual, maxResidual);
thermo.correct();
rho = thermo.rho();
if (!transonic)
{
rho.relax();
}
Info<< "rho max/min : "
<< max(rho).value() << " "
<< min(rho).value() << endl;
}

123
applications/solvers/compressible/rhoSimplecFoam/pEqn.H Normal file
View File

@ -0,0 +1,123 @@
volScalarField p0 = p;
volScalarField AU = UEqn().A();
volScalarField AtU = AU - UEqn().H1();
U = UEqn().H()/AU;
UEqn.clear();
bool closedVolume = false;
if (transonic)
{
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
surfaceScalarField phid
(
"phid",
fvc::interpolate(psi*U) & mesh.Sf()
);
surfaceScalarField phic
(
"phic",
fvc::interpolate(rho/AtU - rho/AU)*fvc::snGrad(p)*mesh.magSf()
+ phid*(fvc::interpolate(p) - fvc::interpolate(p, "UD"))
);
refCast<mixedFvPatchScalarField>(p.boundaryField()[1]).refValue()
= p.boundaryField()[1];
fvScalarMatrix pEqn
(
fvm::div(phid, p)
+ fvc::div(phic)
- fvm::Sp(fvc::div(phid), p)
+ fvc::div(phid)*p
- fvm::laplacian(rho/AtU, p)
);
pEqn.setReference(pRefCell, pRefValue);
// Retain the residual from the first iteration
if (nonOrth == 0)
{
eqnResidual = pEqn.solve().initialResidual();
maxResidual = max(eqnResidual, maxResidual);
}
else
{
pEqn.solve();
}
if (nonOrth == nNonOrthCorr)
{
phi == phic + pEqn.flux();
}
}
}
else
{
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
phi = fvc::interpolate(rho*U) & mesh.Sf();
closedVolume = adjustPhi(phi, U, p);
phi += fvc::interpolate(rho/AtU - rho/AU)*fvc::snGrad(p)*mesh.magSf();
fvScalarMatrix pEqn
(
fvc::div(phi)
//- fvm::laplacian(rho/AU, p)
- fvm::laplacian(rho/AtU, p)
);
pEqn.setReference(pRefCell, pRefValue);
// Retain the residual from the first iteration
if (nonOrth == 0)
{
eqnResidual = pEqn.solve().initialResidual();
maxResidual = max(eqnResidual, maxResidual);
}
else
{
pEqn.solve();
}
if (nonOrth == nNonOrthCorr)
{
phi += pEqn.flux();
}
}
}
// The incompressibe for of the continuity error check is appropriate for
// steady-state compressible also.
#include "incompressible/continuityErrs.H"
// Explicitly relax pressure for momentum corrector
p.relax();
U -= (fvc::grad(p0)*(1.0/AU - 1.0/AtU) + fvc::grad(p)/AtU);
//U -= fvc::grad(p)/AU;
U.correctBoundaryConditions();
bound(p, pMin);
// For closed-volume cases adjust the pressure and density levels
// to obey overall mass continuity
if (closedVolume)
{
p += (initialMass - fvc::domainIntegrate(psi*p))
/fvc::domainIntegrate(psi);
}
rho = thermo.rho();
if (!transonic)
{
rho.relax();
}
Info<< "rho max/min : " << max(rho).value() << " " << min(rho).value() << endl;

92
applications/solvers/compressible/rhoSimplecFoam/rhoSimplecFoam.C Normal file
View File

@ -0,0 +1,92 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Application
rhoSimplecFoam
Description
Steady-state SIMPLEC solver for laminar or turbulent RANS flow of
compressible fluids.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "basicPsiThermo.H"
#include "RASModel.H"
#include "mixedFvPatchFields.H"
#include "bound.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "createFields.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
for (runTime++; !runTime.end(); runTime++)
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readSIMPLEControls.H"
#include "initConvergenceCheck.H"
p.storePrevIter();
if (!transonic)
{
rho.storePrevIter();
}
// Velocity-pressure-enthalpy SIMPLEC corrector
{
#include "UEqn.H"
#include "pEqn.H"
#include "hEqn.H"
}
turbulence->correct();
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
#include "convergenceCheck.H"
}
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

8
applications/solvers/discreteMethods/molecularDynamics/mdEquilibrationFoam/mdEquilibrationFoam.C
View File

@ -50,14 +50,14 @@ int main(int argc, char *argv[])
label nAveragingSteps = 0;
Info << "\nStarting time loop\n" << endl;
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
nAveragingSteps++;
Info << "Time = " << runTime.timeName() << endl;
Info<< "Time = " << runTime.timeName() << endl;
molecules.evolve();
@ -74,12 +74,12 @@ int main(int argc, char *argv[])
nAveragingSteps = 0;
}
Info << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

8
applications/solvers/discreteMethods/molecularDynamics/mdFoam/mdFoam.C
View File

@ -48,14 +48,14 @@ int main(int argc, char *argv[])
label nAveragingSteps = 0;
Info << "\nStarting time loop\n" << endl;
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
nAveragingSteps++;
Info << "Time = " << runTime.timeName() << endl;
Info<< "Time = " << runTime.timeName() << endl;
molecules.evolve();
@ -70,12 +70,12 @@ int main(int argc, char *argv[])
nAveragingSteps = 0;
}
Info << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

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

@ -117,7 +117,7 @@ int main(int argc, char *argv[])
<< nl << endl;
}
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

5
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/Make/files Normal file
View File

@ -0,0 +1,5 @@
derivedFvPatchFields/solidWallHeatFluxTemperature/solidWallHeatFluxTemperatureFvPatchScalarField.C
chtMultiRegionSimpleFoam.C
EXE = $(FOAM_APPBIN)/chtMultiRegionSimpleFoam

16
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/Make/options Normal file
View File

@ -0,0 +1,16 @@
EXE_INC = \
/* -DFULLDEBUG -O0 -g */ \
-Ifluid \
-Isolid \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/turbulenceModels \
-I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude \
-I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude
EXE_LIBS = \
-lfiniteVolume \
-lbasicThermophysicalModels \
-lspecie \
-lcompressibleRASModels

99
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/chtMultiRegionSimpleFoam.C Normal file
View File

@ -0,0 +1,99 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Application
chtMultiRegionSimpleFoam
Description
Steady-state version of chtMultiRegionFoam
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "basicPsiThermo.H"
#include "turbulenceModel.H"
#include "fixedGradientFvPatchFields.H"
#include "regionProperties.H"
#include "compressibleCourantNo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
regionProperties rp(runTime);
#include "createFluidMeshes.H"
#include "createSolidMeshes.H"
#include "createFluidFields.H"
#include "createSolidFields.H"
#include "initContinuityErrs.H"
while (runTime.run())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
forAll(fluidRegions, i)
{
Info<< "\nSolving for fluid region "
<< fluidRegions[i].name() << endl;
#include "setRegionFluidFields.H"
#include "readFluidMultiRegionSIMPLEControls.H"
#include "initConvergenceCheck.H"
#include "solveFluid.H"
#include "convergenceCheck.H"
}
forAll(solidRegions, i)
{
Info<< "\nSolving for solid region "
<< solidRegions[i].name() << endl;
#include "setRegionSolidFields.H"
#include "readSolidMultiRegionSIMPLEControls.H"
#include "initConvergenceCheck.H"
#include "solveSolid.H"
#include "convergenceCheck.H"
}
runTime++;
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

168
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/derivedFvPatchFields/solidWallHeatFluxTemperature/solidWallHeatFluxTemperatureFvPatchScalarField.C Normal file
View File

@ -0,0 +1,168 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
\*---------------------------------------------------------------------------*/
#include "solidWallHeatFluxTemperatureFvPatchScalarField.H"
#include "addToRunTimeSelectionTable.H"
#include "fvPatchFieldMapper.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::solidWallHeatFluxTemperatureFvPatchScalarField::
solidWallHeatFluxTemperatureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF
)
:
fixedValueFvPatchScalarField(p, iF),
q_(p.size(), 0.0),
KName_("undefined-K")
{}
Foam::solidWallHeatFluxTemperatureFvPatchScalarField::
solidWallHeatFluxTemperatureFvPatchScalarField
(
const solidWallHeatFluxTemperatureFvPatchScalarField& ptf,
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
fixedValueFvPatchScalarField(ptf, p, iF, mapper),
q_(ptf.q_, mapper),
KName_(ptf.KName_)
{}
Foam::solidWallHeatFluxTemperatureFvPatchScalarField::
solidWallHeatFluxTemperatureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF, dict),
q_("q", dict, p.size()),
KName_(dict.lookup("K"))
{}
Foam::solidWallHeatFluxTemperatureFvPatchScalarField::
solidWallHeatFluxTemperatureFvPatchScalarField
(
const solidWallHeatFluxTemperatureFvPatchScalarField& tppsf
)
:
fixedValueFvPatchScalarField(tppsf),
q_(tppsf.q_),
KName_(tppsf.KName_)
{}
Foam::solidWallHeatFluxTemperatureFvPatchScalarField::
solidWallHeatFluxTemperatureFvPatchScalarField
(
const solidWallHeatFluxTemperatureFvPatchScalarField& tppsf,
const DimensionedField<scalar, volMesh>& iF
)
:
fixedValueFvPatchScalarField(tppsf, iF),
q_(tppsf.q_),
KName_(tppsf.KName_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::solidWallHeatFluxTemperatureFvPatchScalarField::autoMap
(
const fvPatchFieldMapper& m
)
{
fixedValueFvPatchScalarField::autoMap(m);
q_.autoMap(m);
}
void Foam::solidWallHeatFluxTemperatureFvPatchScalarField::rmap
(
const fvPatchScalarField& ptf,
const labelList& addr
)
{
fixedValueFvPatchScalarField::rmap(ptf, addr);
const solidWallHeatFluxTemperatureFvPatchScalarField& hfptf =
refCast<const solidWallHeatFluxTemperatureFvPatchScalarField>(ptf);
q_.rmap(hfptf.q_, addr);
}
void Foam::solidWallHeatFluxTemperatureFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
const scalarField& Kw =
patch().lookupPatchField<volScalarField, scalar>(KName_);
const fvPatchScalarField& Tw = *this;
operator==(q_/(patch().deltaCoeffs()*Kw) + Tw.patchInternalField());
fixedValueFvPatchScalarField::updateCoeffs();
}
void Foam::solidWallHeatFluxTemperatureFvPatchScalarField::write
(
Ostream& os
) const
{
fixedValueFvPatchScalarField::write(os);
q_.writeEntry("q", os);
os.writeKeyword("K") << KName_ << token::END_STATEMENT << nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makePatchTypeField
(
fvPatchScalarField,
solidWallHeatFluxTemperatureFvPatchScalarField
);
}
// ************************************************************************* //

181
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/derivedFvPatchFields/solidWallHeatFluxTemperature/solidWallHeatFluxTemperatureFvPatchScalarField.H Normal file
View File

@ -0,0 +1,181 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Class
solidWallHeatFluxTemperatureFvPatchScalarField
Description
Heat flux boundary condition for temperature on solid region
Example usage:
myWallPatch
{
type solidWallHeatFluxTemperature;
K K; // Name of K field
q uniform 1000; // Heat flux / [W/m2]
value 300.0; // Initial temperature / [K]
}
SourceFiles
solidWallHeatFluxTemperatureFvPatchScalarField.C
\*---------------------------------------------------------------------------*/
#ifndef solidWallHeatFluxTemperatureFvPatchScalarField_H
#define solidWallHeatFluxTemperatureFvPatchScalarField_H
#include "fixedValueFvPatchFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class solidWallHeatFluxTemperatureFvPatchScalarField Declaration
\*---------------------------------------------------------------------------*/
class solidWallHeatFluxTemperatureFvPatchScalarField
:
public fixedValueFvPatchScalarField
{
// Private data
//- Heat flux / [W/m2]
scalarField q_;
//- Name of thermal conductivity field
word KName_;
public:
//- Runtime type information
TypeName("solidWallHeatFluxTemperature");
// Constructors
//- Construct from patch and internal field
solidWallHeatFluxTemperatureFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&
);
//- Construct from patch, internal field and dictionary
solidWallHeatFluxTemperatureFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const dictionary&
);
//- Construct by mapping given
// solidWallHeatFluxTemperatureFvPatchScalarField
// onto a new patch
solidWallHeatFluxTemperatureFvPatchScalarField
(
const solidWallHeatFluxTemperatureFvPatchScalarField&,
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const fvPatchFieldMapper&
);
//- Construct as copy
solidWallHeatFluxTemperatureFvPatchScalarField
(
const solidWallHeatFluxTemperatureFvPatchScalarField&
);
//- Construct and return a clone
virtual tmp<fvPatchScalarField> clone() const
{
return tmp<fvPatchScalarField>
(
new solidWallHeatFluxTemperatureFvPatchScalarField(*this)
);
}
//- Construct as copy setting internal field reference
solidWallHeatFluxTemperatureFvPatchScalarField
(
const solidWallHeatFluxTemperatureFvPatchScalarField&,
const DimensionedField<scalar, volMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<fvPatchScalarField> clone
(
const DimensionedField<scalar, volMesh>& iF
) const
{
return tmp<fvPatchScalarField>
(
new solidWallHeatFluxTemperatureFvPatchScalarField(*this, iF)
);
}
// Member functions
// Evaluation functions
//- Update the coefficients associated with the patch field
virtual void updateCoeffs();
// Mapping functions
//- Map (and resize as needed) from self given a mapping object
virtual void autoMap
(
const fvPatchFieldMapper&
);
//- Reverse map the given fvPatchField onto this fvPatchField
virtual void rmap
(
const fvPatchScalarField&,
const labelList&
);
// I-O
//- Write
void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

22
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/UEqn.H Normal file
View File

@ -0,0 +1,22 @@
// Solve the Momentum equation
tmp<fvVectorMatrix> UEqn
(
fvm::div(phi, U)
- fvm::Sp(fvc::div(phi), U)
+ turb.divDevRhoReff(U)
);
UEqn().relax();
eqnResidual = solve
(
UEqn()
==
fvc::reconstruct
(
fvc::interpolate(rho)*(g & mesh.Sf())
- fvc::snGrad(p)*mesh.magSf()
)
).initialResidual();
maxResidual = max(eqnResidual, maxResidual);

21
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/compressibleContinuityErrors.H Normal file
View File

@ -0,0 +1,21 @@
{
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[i] += globalContErr;
Info<< "time step continuity errors (" << mesh.name() << ")"
<< ": sum local = " << sumLocalContErr
<< ", global = " << globalContErr
<< ", cumulative = " << cumulativeContErr[i]
<< endl;
}

63
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/compressibleCourantNo.C Normal file
View File

@ -0,0 +1,63 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
\*---------------------------------------------------------------------------*/
#include "compressibleCourantNo.H"
#include "fvc.H"
Foam::scalar Foam::compressibleCourantNo
(
const fvMesh& mesh,
const Time& runTime,
const volScalarField& rho,
const surfaceScalarField& phi
)
{
scalar CoNum = 0.0;
scalar meanCoNum = 0.0;
//- Can have fluid domains with 0 cells so do not test.
//if (mesh.nInternalFaces())
{
surfaceScalarField SfUfbyDelta =
mesh.surfaceInterpolation::deltaCoeffs()
* mag(phi)
/ fvc::interpolate(rho);
CoNum = max(SfUfbyDelta/mesh.magSf())
.value()*runTime.deltaT().value();
meanCoNum = (sum(SfUfbyDelta)/sum(mesh.magSf()))
.value()*runTime.deltaT().value();
}
Info<< "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum
<< " max: " << CoNum << endl;
return CoNum;
}
// ************************************************************************* //

49
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/compressibleCourantNo.H Normal file
View File

@ -0,0 +1,49 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Calculates and outputs the mean and maximum Courant Numbers for the fluid
regions
\*---------------------------------------------------------------------------*/
#ifndef compressibleCourantNo_H
#define compressibleCourantNo_H
#include "fvMesh.H"
namespace Foam
{
scalar compressibleCourantNo
(
const fvMesh& mesh,
const Time& runTime,
const volScalarField& rho,
const surfaceScalarField& phi
);
}
#endif
// ************************************************************************* //

15
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/compressibleMultiRegionCourantNo.H Normal file
View File

@ -0,0 +1,15 @@
scalar CoNum = -GREAT;
forAll(fluidRegions, regionI)
{
CoNum = max
(
compressibleCourantNo
(
fluidRegions[regionI],
runTime,
rhoFluid[regionI],
phiFluid[regionI]
),
CoNum
);
}

12
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/convergenceCheck.H Normal file
View File

@ -0,0 +1,12 @@
// check convergence
Info<< "maxResidual: " << maxResidual
<< " convergence criterion: " << convergenceCriterion
<< endl;
if (maxResidual < convergenceCriterion)
{
Info<< "reached convergence criterion: " << convergenceCriterion << endl;
runTime.writeAndEnd();
Info<< "latestTime = " << runTime.timeName() << endl;
}

144
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/createFluidFields.H Normal file
View File

@ -0,0 +1,144 @@
// Initialise fluid field pointer lists
PtrList<basicPsiThermo> thermoFluid(fluidRegions.size());
PtrList<volScalarField> rhoFluid(fluidRegions.size());
PtrList<volScalarField> KFluid(fluidRegions.size());
PtrList<volVectorField> UFluid(fluidRegions.size());
PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> DpDtf(fluidRegions.size());
List<scalar> initialMassFluid(fluidRegions.size());
List<label> pRefCellFluid(fluidRegions.size(),0);
List<scalar> pRefValueFluid(fluidRegions.size(),0.0);
// Populate fluid field pointer lists
forAll(fluidRegions, i)
{
Info<< "*** Reading fluid mesh thermophysical properties for region "
<< fluidRegions[i].name() << nl << endl;
Info<< " Adding to thermoFluid\n" << endl;
thermoFluid.set
(
i,
basicPsiThermo::New(fluidRegions[i]).ptr()
);
Info<< " Adding to rhoFluid\n" << endl;
rhoFluid.set
(
i,
new volScalarField
(
IOobject
(
"rho",
runTime.timeName(),
fluidRegions[i],
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermoFluid[i].rho()
)
);
Info<< " Adding to KFluid\n" << endl;
KFluid.set
(
i,
new volScalarField
(
IOobject
(
"K",
runTime.timeName(),
fluidRegions[i],
IOobject::NO_READ,
IOobject::NO_WRITE
),
thermoFluid[i].Cp()*thermoFluid[i].alpha()
)
);
Info<< " Adding to UFluid\n" << endl;
UFluid.set
(
i,
new volVectorField
(
IOobject
(
"U",
runTime.timeName(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
fluidRegions[i]
)
);
Info<< " Adding to phiFluid\n" << endl;
phiFluid.set
(
i,
new surfaceScalarField
(
IOobject
(
"phi",
runTime.timeName(),
fluidRegions[i],
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(rhoFluid[i]*UFluid[i])
& fluidRegions[i].Sf()
)
);
Info<< " Adding to gFluid\n" << endl;
gFluid.set
(
i,
new uniformDimensionedVectorField
(
IOobject
(
"g",
runTime.constant(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
Info<< " Adding to turbulence\n" << endl;
turbulence.set
(
i,
compressible::turbulenceModel::New
(
rhoFluid[i],
UFluid[i],
phiFluid[i],
thermoFluid[i]
).ptr()
);
initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
setRefCell
(
thermoFluid[i].p(),
fluidRegions[i].solutionDict().subDict("SIMPLE"),
pRefCellFluid[i],
pRefValueFluid[i]
);
}

22
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/createFluidMeshes.H Normal file
View File

@ -0,0 +1,22 @@
PtrList<fvMesh> fluidRegions(rp.fluidRegionNames().size());
forAll(rp.fluidRegionNames(), i)
{
Info<< "Create fluid mesh for region " << rp.fluidRegionNames()[i]
<< " for time = " << runTime.timeName() << nl << endl;
fluidRegions.set
(
i,
new fvMesh
(
IOobject
(
rp.fluidRegionNames()[i],
runTime.timeName(),
runTime,
IOobject::MUST_READ
)
)
);
}

21
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/hEqn.H Normal file
View File

@ -0,0 +1,21 @@
{
fvScalarMatrix hEqn
(
fvm::div(phi, h)
- fvm::Sp(fvc::div(phi), h)
- fvm::laplacian(turb.alphaEff(), h)
==
fvc::div(phi/fvc::interpolate(rho)*fvc::interpolate(p))
- p*fvc::div(phi/fvc::interpolate(rho))
);
hEqn.relax();
eqnResidual = hEqn.solve().initialResidual();
maxResidual = max(eqnResidual, maxResidual);
thermo.correct();
Info<< "Min/max T:" << min(thermo.T()).value() << ' '
<< max(thermo.T()).value() << endl;
}

7
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/initConvergenceCheck.H Normal file
View File

@ -0,0 +1,7 @@
// initialize values for convergence checks
scalar eqnResidual = 1, maxResidual = 0;
scalar convergenceCriterion = 0;
simple.readIfPresent("convergence", convergenceCriterion);

74
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/pEqn.H Normal file
View File

@ -0,0 +1,74 @@
{
// From buoyantSimpleFoam
rho = thermo.rho();
volScalarField rUA = 1.0/UEqn().A();
surfaceScalarField rhorUAf("(rho*(1|A(U)))", fvc::interpolate(rho*rUA));
U = rUA*UEqn().H();
UEqn.clear();
phi = fvc::interpolate(rho)*(fvc::interpolate(U) & mesh.Sf());
bool closedVolume = adjustPhi(phi, U, p);
surfaceScalarField buoyancyPhi =
rhorUAf*fvc::interpolate(rho)*(g & mesh.Sf());
phi += buoyancyPhi;
// Solve pressure
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(
fvm::laplacian(rhorUAf, p) == fvc::div(phi)
);
pEqn.setReference(pRefCell, pRefValue);
// retain the residual from the first iteration
if (nonOrth == 0)
{
eqnResidual = pEqn.solve().initialResidual();
maxResidual = max(eqnResidual, maxResidual);
}
else
{
pEqn.solve();
}
if (nonOrth == nNonOrthCorr)
{
// For closed-volume cases adjust the pressure and density levels
// to obey overall mass continuity
if (closedVolume)
{
p += (initialMass - fvc::domainIntegrate(psi*p))
/fvc::domainIntegrate(psi);
}
// Calculate the conservative fluxes
phi -= pEqn.flux();
// Explicitly relax pressure for momentum corrector
p.relax();
// Correct the momentum source with the pressure gradient flux
// calculated from the relaxed pressure
U += rUA*fvc::reconstruct((buoyancyPhi - pEqn.flux())/rhorUAf);
U.correctBoundaryConditions();
}
}
#include "continuityErrs.H"
rho = thermo.rho();
rho.relax();
Info<< "Min/max rho:" << min(rho).value() << ' '
<< max(rho).value() << endl;
// Update thermal conductivity
K = thermo.Cp()*turb.alphaEff();
}

25
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/readFluidMultiRegionSIMPLEControls.H Normal file
View File

@ -0,0 +1,25 @@
dictionary simple = fluidRegions[i].solutionDict().subDict("SIMPLE");
int nNonOrthCorr = 0;
if (simple.found("nNonOrthogonalCorrectors"))
{
nNonOrthCorr = readInt(simple.lookup("nNonOrthogonalCorrectors"));
}
bool momentumPredictor = true;
if (simple.found("momentumPredictor"))
{
momentumPredictor = Switch(simple.lookup("momentumPredictor"));
}
bool fluxGradp = false;
if (simple.found("fluxGradp"))
{
fluxGradp = Switch(simple.lookup("fluxGradp"));
}
bool transonic = false;
if (simple.found("transonic"))
{
transonic = Switch(simple.lookup("transonic"));
}

24
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/setRegionFluidFields.H Normal file
View File

@ -0,0 +1,24 @@
const fvMesh& mesh = fluidRegions[i];
basicPsiThermo& thermo = thermoFluid[i];
volScalarField& rho = rhoFluid[i];
volScalarField& K = KFluid[i];
volVectorField& U = UFluid[i];
surfaceScalarField& phi = phiFluid[i];
const dimensionedVector& g = gFluid[i];
compressible::turbulenceModel& turb = turbulence[i];
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& h = thermo.h();
const dimensionedScalar initialMass
(
"initialMass",
dimMass,
initialMassFluid[i]
);
const label pRefCell = pRefCellFluid[i];
const scalar pRefValue = pRefValueFluid[i];

11
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/fluid/solveFluid.H Normal file
View File

@ -0,0 +1,11 @@
// Pressure-velocity SIMPLE corrector
p.storePrevIter();
rho.storePrevIter();
{
#include "UEqn.H"
#include "hEqn.H"
#include "pEqn.H"
}
turb.correct();

91
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/solid/createSolidFields.H Normal file
View File

@ -0,0 +1,91 @@
// Initialise solid field pointer lists
PtrList<volScalarField> rhos(solidRegions.size());
PtrList<volScalarField> cps(solidRegions.size());
PtrList<volScalarField> rhosCps(solidRegions.size());
PtrList<volScalarField> Ks(solidRegions.size());
PtrList<volScalarField> Ts(solidRegions.size());
// Populate solid field pointer lists
forAll(solidRegions, i)
{
Info<< "*** Reading solid mesh thermophysical properties for region "
<< solidRegions[i].name() << nl << endl;
Info<< " Adding to rhos\n" << endl;
rhos.set
(
i,
new volScalarField
(
IOobject
(
"rho",
runTime.timeName(),
solidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
solidRegions[i]
)
);
Info<< " Adding to cps\n" << endl;
cps.set
(
i,
new volScalarField
(
IOobject
(
"cp",
runTime.timeName(),
solidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
solidRegions[i]
)
);
rhosCps.set
(
i,
new volScalarField("rhosCps", rhos[i]*cps[i])
);
Info<< " Adding to Ks\n" << endl;
Ks.set
(
i,
new volScalarField
(
IOobject
(
"K",
runTime.timeName(),
solidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
solidRegions[i]
)
);
Info<< " Adding to Ts\n" << endl;
Ts.set
(
i,
new volScalarField
(
IOobject
(
"T",
runTime.timeName(),
solidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
solidRegions[i]
)
);
}

27
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/solid/createSolidMeshes.H Normal file
View File

@ -0,0 +1,27 @@
PtrList<fvMesh> solidRegions(rp.solidRegionNames().size());
forAll(rp.solidRegionNames(), i)
{
Info<< "Create solid mesh for region " << rp.solidRegionNames()[i]
<< " for time = " << runTime.timeName() << nl << endl;
solidRegions.set
(
i,
new fvMesh
(
IOobject
(
rp.solidRegionNames()[i],
runTime.timeName(),
runTime,
IOobject::MUST_READ
)
)
);
// Force calculation of geometric properties to prevent it being done
// later in e.g. some boundary evaluation
//(void)solidRegions[i].weights();
//(void)solidRegions[i].deltaCoeffs();
}

7
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/solid/readSolidMultiRegionSIMPLEControls.H Normal file
View File

@ -0,0 +1,7 @@
dictionary simple = solidRegions[i].solutionDict().subDict("SIMPLE");
int nNonOrthCorr = 0;
if (simple.found("nNonOrthogonalCorrectors"))
{
nNonOrthCorr = readInt(simple.lookup("nNonOrthogonalCorrectors"));
}

6
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/solid/setRegionSolidFields.H Normal file
View File

@ -0,0 +1,6 @@
fvMesh& mesh = solidRegions[i];
volScalarField& rho = rhos[i];
volScalarField& cp = cps[i];
volScalarField& K = Ks[i];
volScalarField& T = Ts[i];

16
applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/solid/solveSolid.H Normal file
View File

@ -0,0 +1,16 @@
{
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix tEqn
(
-fvm::laplacian(K, T)
);
tEqn.relax();
eqnResidual = tEqn.solve().initialResidual();
maxResidual = max(eqnResidual, maxResidual);
}
Info<< "Min/max T:" << min(T).value() << ' '
<< max(T).value() << endl;
}

2
applications/solvers/incompressible/channelFoam/createGradP.H
View File

@ -11,7 +11,7 @@
runTime.path()/runTime.timeName()/"uniform"/"gradP.raw"
);
if(gradPFile.good())
if (gradPFile.good())
{
gradPFile >> gradP;
Info<< "Reading average pressure gradient" <<endl

2
applications/solvers/incompressible/channelFoam/writeGradP.H
View File

@ -5,7 +5,7 @@
runTime.path()/runTime.timeName()/"uniform"/"gradP.raw"
);
if(gradPFile.good())
if (gradPFile.good())
{
gradPFile << gradP << endl;
}

26
applications/solvers/incompressible/pimpleDyMFoam/correctPhi.H
View File

@ -1,4 +1,26 @@
{
if (mesh.changing())
{
forAll(U.boundaryField(), patchi)
{
if (U.boundaryField()[patchi].fixesValue())
{
U.boundaryField()[patchi].initEvaluate();
}
}
forAll(U.boundaryField(), patchi)
{
if (U.boundaryField()[patchi].fixesValue())
{
U.boundaryField()[patchi].evaluate();
phi.boundaryField()[patchi] =
U.boundaryField()[patchi] & mesh.Sf().boundaryField()[patchi];
}
}
}
wordList pcorrTypes
(
p.boundaryField().size(),
@ -7,7 +29,7 @@
for (label i=0; i<p.boundaryField().size(); i++)
{
if(p.boundaryField()[i].fixesValue())
if (p.boundaryField()[i].fixesValue())
{
pcorrTypes[i] = fixedValueFvPatchScalarField::typeName;
}
@ -28,7 +50,7 @@
pcorrTypes
);
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pcorrEqn
(

4
applications/solvers/incompressible/porousSimpleFoam/createFields.H
View File

@ -1,4 +1,4 @@
Info << "Reading field p\n" << endl;
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
@ -12,7 +12,7 @@
mesh
);
Info << "Reading field U\n" << endl;
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject

1
applications/solvers/incompressible/shallowWaterFoam/shallowWaterFoam.C
View File

@ -90,7 +90,6 @@ int main(int argc, char *argv[])
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
surfaceScalarField hf = fvc::interpolate(h);
volScalarField rUA = 1.0/hUEqn.A();
surfaceScalarField ghrUAf = magg*fvc::interpolate(h*rUA);

4
applications/solvers/incompressible/simpleFoam/createFields.H
View File

@ -1,4 +1,4 @@
Info << "Reading field p\n" << endl;
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
@ -12,7 +12,7 @@
mesh
);
Info << "Reading field U\n" << endl;
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject

2
applications/solvers/lagrangian/coalChemistryFoam/chemistry.H
View File

@ -1,5 +1,5 @@
{
Info << "Solving chemistry" << endl;
Info<< "Solving chemistry" << endl;
chemistry.solve
(

2
applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/chemistry.H
View File

@ -1,5 +1,5 @@
{
Info << "Solving chemistry" << endl;
Info<< "Solving chemistry" << endl;
chemistry.solve
(

21
applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/readAdditionalSolutionControls.H
View File

@ -1,20 +1,5 @@
dictionary additional = mesh.solutionDict().subDict("additional");
bool dpdt = true;
if (additional.found("dpdt"))
{
additional.lookup("dpdt") >> dpdt;
}
bool eWork = true;
if (additional.found("eWork"))
{
additional.lookup("eWork") >> eWork;
}
bool hWork = true;
if (additional.found("hWork"))
{
additional.lookup("hWork") >> hWork;
}
bool dpdt = additional.lookupOrDefault("dpdt", true);
bool eWork = additional.lookupOrDefault("eWork", true);
bool hWork = additional.lookupOrDefault("hWork", true);

2
applications/solvers/lagrangian/reactingParcelFoam/chemistry.H
View File

@ -1,5 +1,5 @@
{
Info << "Solving chemistry" << endl;
Info<< "Solving chemistry" << endl;
chemistry.solve
(

2
applications/solvers/multiphase/bubbleFoam/kEpsilon.H
View File

@ -1,4 +1,4 @@
if(turbulence)
if (turbulence)
{
if (mesh.changing())
{

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

@ -34,7 +34,7 @@
surfaceScalarField Dp("(rho*(1|A(U)))", alphaf*rUaAf/rhoa + betaf*rUbAf/rhob);
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

24
applications/solvers/multiphase/compressibleInterDyMFoam/correctPhi.H
View File

@ -1,4 +1,26 @@
{
if (mesh.changing())
{
forAll(U.boundaryField(), patchi)
{
if (U.boundaryField()[patchi].fixesValue())
{
U.boundaryField()[patchi].initEvaluate();
}
}
forAll(U.boundaryField(), patchi)
{
if (U.boundaryField()[patchi].fixesValue())
{
U.boundaryField()[patchi].evaluate();
phi.boundaryField()[patchi] =
U.boundaryField()[patchi] & mesh.Sf().boundaryField()[patchi];
}
}
}
#include "continuityErrs.H"
volScalarField pcorr
@ -20,7 +42,7 @@
adjustPhi(phi, U, pcorr);
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pcorrEqn
(

2
applications/solvers/multiphase/compressibleInterFoam/pEqn.H
View File

@ -30,7 +30,7 @@
+ fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf;
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqnIncomp
(

24
applications/solvers/multiphase/interDyMFoam/correctPhi.H
View File

@ -1,4 +1,26 @@
{
if (mesh.changing())
{
forAll(U.boundaryField(), patchi)
{
if (U.boundaryField()[patchi].fixesValue())
{
U.boundaryField()[patchi].initEvaluate();
}
}
forAll(U.boundaryField(), patchi)
{
if (U.boundaryField()[patchi].fixesValue())
{
U.boundaryField()[patchi].evaluate();
phi.boundaryField()[patchi] =
U.boundaryField()[patchi] & mesh.Sf().boundaryField()[patchi];
}
}
}
#include "continuityErrs.H"
volScalarField pcorr
@ -20,7 +42,7 @@
adjustPhi(phi, U, pcorr);
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pcorrEqn
(

2
applications/solvers/multiphase/interDyMFoam/pEqn.H
View File

@ -18,7 +18,7 @@
+ fvc::interpolate(rho)*(g & mesh.Sf())
)*rAUf;
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

2
applications/solvers/multiphase/interFoam/correctPhi.H
View File

@ -34,7 +34,7 @@
adjustPhi(phi, U, pcorr);
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pcorrEqn
(

2
applications/solvers/multiphase/interFoam/pEqn.H
View File

@ -19,7 +19,7 @@
+ fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf;
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

2
applications/solvers/multiphase/interPhaseChangeFoam/correctPhi.H
View File

@ -34,7 +34,7 @@
adjustPhi(phi, U, pcorr);
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pcorrEqn
(

2
applications/solvers/multiphase/interPhaseChangeFoam/pEqn.H
View File

@ -23,7 +23,7 @@
const volScalarField& vDotcP = vDotP[0]();
const volScalarField& vDotvP = vDotP[1]();
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

10
applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/multiphaseMixture.C
View File

@ -125,7 +125,7 @@ Foam::tmp<Foam::volScalarField> Foam::multiphaseMixture::rho() const
tmp<volScalarField> trho = iter()*iter().rho();
for(++iter; iter != phases_.end(); ++iter)
for (++iter; iter != phases_.end(); ++iter)
{
trho() += iter()*iter().rho();
}
@ -140,7 +140,7 @@ Foam::tmp<Foam::volScalarField> Foam::multiphaseMixture::mu() const
tmp<volScalarField> tmu = iter()*iter().rho()*iter().nu();
for(++iter; iter != phases_.end(); ++iter)
for (++iter; iter != phases_.end(); ++iter)
{
tmu() += iter()*iter().rho()*iter().nu();
}
@ -156,7 +156,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::multiphaseMixture::muf() const
tmp<surfaceScalarField> tmuf =
fvc::interpolate(iter())*iter().rho()*fvc::interpolate(iter().nu());
for(++iter; iter != phases_.end(); ++iter)
for (++iter; iter != phases_.end(); ++iter)
{
tmuf() +=
fvc::interpolate(iter())*iter().rho()*fvc::interpolate(iter().nu());
@ -210,7 +210,7 @@ Foam::multiphaseMixture::surfaceTensionForce() const
PtrDictionary<phase>::const_iterator iter2 = iter1;
++iter2;
for(; iter2 != phases_.end(); ++iter2)
for (; iter2 != phases_.end(); ++iter2)
{
const phase& alpha2 = iter2();
@ -489,7 +489,7 @@ void Foam::multiphaseMixture::solveAlphas
if (cycleAlpha)
{
PtrDictionary<phase>::iterator refPhaseIter = phases_.begin();
for(label i=0; i<nSolves%phases_.size(); i++)
for (label i=0; i<nSolves%phases_.size(); i++)
{
++refPhaseIter;
}

2
applications/solvers/multiphase/multiphaseInterFoam/pEqn.H
View File

@ -18,7 +18,7 @@
+ fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf;
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

2
applications/solvers/multiphase/settlingFoam/pEqn.H
View File

@ -17,7 +17,7 @@ phi =
surfaceScalarField phiU("phiU", phi);
phi += fvc::interpolate(rho)*(g & mesh.Sf())*rUAf;
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

2
applications/solvers/multiphase/twoLiquidMixingFoam/pEqn.H
View File

@ -13,7 +13,7 @@
phi = phiU + fvc::interpolate(rho)*(g & mesh.Sf())*rUAf;
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

2
applications/solvers/multiphase/twoPhaseEulerFoam/createFields.H
View File

@ -190,7 +190,7 @@
}
}
Info << "dragPhase is " << dragPhase << endl;
Info<< "dragPhase is " << dragPhase << endl;
kineticTheoryModel kineticTheory
(
phasea,

4
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/GidaspowErgunWenYu/GidaspowErgunWenYu.C
View File

@ -78,12 +78,12 @@ Foam::tmp<Foam::volScalarField> Foam::GidaspowErgunWenYu::K
forAll(Re, celli)
{
if(Re[celli] > 1000.0)
if (Re[celli] > 1000.0)
{
Cds[celli] = 0.44;
}
}
// Wen and Yu (1966)
tmp<volScalarField> tKWenYu = 0.75*Cds*phaseb_.rho()*Ur*bp/phasea_.d();
volScalarField& KWenYu = tKWenYu();

2
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/GidaspowSchillerNaumann/GidaspowSchillerNaumann.C
View File

@ -77,7 +77,7 @@ Foam::tmp<Foam::volScalarField> Foam::GidaspowSchillerNaumann::K
forAll(Re, celli)
{
if(Re[celli] > 1000.0)
if (Re[celli] > 1000.0)
{
Cds[celli] = 0.44;
}

2
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/SchillerNaumann/SchillerNaumann.C
View File

@ -74,7 +74,7 @@ Foam::tmp<Foam::volScalarField> Foam::SchillerNaumann::K
forAll(Re, celli)
{
if(Re[celli] > 1000.0)
if (Re[celli] > 1000.0)
{
Cds[celli] = 0.44;
}

2
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/WenYu/WenYu.C
View File

@ -77,7 +77,7 @@ Foam::tmp<Foam::volScalarField> Foam::WenYu::K
forAll(Re, celli)
{
if(Re[celli] > 1000.0)
if (Re[celli] > 1000.0)
{
Cds[celli] = 0.44;
}

4
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/dragModel/newDragModel.C
View File

@ -41,7 +41,7 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
interfaceDict.lookup("dragModel" + phasea.name())
);
Info << "Selecting dragModel for phase "
Info<< "Selecting dragModel for phase "
<< phasea.name()
<< ": "
<< dragModelType << endl;
@ -57,7 +57,7 @@ Foam::autoPtr<Foam::dragModel> Foam::dragModel::New
<< dragModelType
<< ", constructor not in hash table" << endl << endl
<< " Valid dragModel types are : " << endl;
Info << dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
Info<< dictionaryConstructorTablePtr_->sortedToc() << abort(FatalError);
}
return cstrIter()(interfaceDict, alpha, phasea, phaseb);

2
applications/solvers/multiphase/twoPhaseEulerFoam/pEqn.H
View File

@ -47,7 +47,7 @@
surfaceScalarField Dp("(rho*(1|A(U)))", alphaf*rUaAf/rhoa + betaf*rUbAf/rhob);
for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(

14
applications/test/Dictionary/DictionaryTest.C
View File

@ -84,7 +84,7 @@ public:
~Scalar()
{
Info <<"delete Scalar: " << data_ << endl;
Info<<"delete Scalar: " << data_ << endl;
}
friend Ostream& operator<<(Ostream& os, const Scalar& val)
@ -169,7 +169,7 @@ int main(int argc, char *argv[])
{
Info<< " = " << iter() << endl;
}
PtrDictionary<Scalar> scalarDict2;
for (int i = 8; i<15; i++)
{
@ -186,22 +186,22 @@ int main(int argc, char *argv[])
{
Info<< "elem = " << *iter << endl;
}
scalarDict.transfer(scalarDict2);
Scalar* p = scalarDict.lookupPtr("ent8");
// This does not (yet) work
// Scalar* q = scalarDict.remove("ent10");
if (p)
{
Info << "found: " << *p << endl;
Info<< "found: " << *p << endl;
}
else
{
Info << "no p: " << endl;
Info<< "no p: " << endl;
}
scalarDict.clear();

133
applications/test/DimensionedField/DimensionedFieldTest.C
View File

@ -1,133 +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
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "Time.H"
#include "DimensionedFields.H"
#include "DimensionedSphericalTensorField.H"
#include "vector.H"
#include "tensor.H"
#include "GeoMesh.H"
using namespace Foam;
namespace Foam
{
class vMesh
{
public:
vMesh()
{}
label size() const
{
return 10;
}
};
};
template<>
const word Foam::DimensionedField<scalar, GeoMesh<vMesh> >::typeName
(
"dimenionedScalarField"
);
template<>
const word Foam::DimensionedField<vector, GeoMesh<vMesh> >::typeName
(
"dimenionedVectorField"
);
template<>
const word Foam::DimensionedField<tensor, GeoMesh<vMesh> >::typeName
(
"dimenionedTensorField"
);
template<>
const word Foam::DimensionedField<sphericalTensor, GeoMesh<vMesh> >::typeName
(
"dimenionedSphericalTensorField"
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
vMesh vm;
DimensionedField<scalar, GeoMesh<vMesh> > dsf
(
IOobject
(
"dsf",
runTime.timeName(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
vm
);
Info<< dsf << endl;
dsf += dsf;
dsf -= dimensionedScalar("5", dsf.dimensions(), 5.0);
Info<< dsf << endl;
Info<< sqr(dsf + dsf) - sqr(dsf + dsf) << endl;
DimensionedField<vector, GeoMesh<vMesh> > dvf
(
IOobject
(
"dvf",
runTime.timeName(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
vm
);
Info<< (dvf ^ (dvf ^ dvf)) << endl;
Info << "End\n" << endl;
return 0;
}
// ************************************************************************* //

3
applications/test/DimensionedField/Make/files
View File

@ -1,3 +0,0 @@
DimensionedFieldTest.C
EXE = $(FOAM_USER_APPBIN)/DimensionedFieldTest

2
applications/test/DimensionedField/Make/options
View File

@ -1,2 +0,0 @@
/* EXE_INC = -I$(LIB_SRC)/cfdTools/include */
/* EXE_LIBS = -lfiniteVolume */

13
applications/test/HashSet/hashSetTest.C
View File

@ -92,6 +92,8 @@ int main(int argc, char *argv[])
labelHashSet setD(1);
setD.insert(11);
setD.insert(100);
setD.insert(49);
setD.insert(36);
setD.insert(2008);
Info<< "setD : " << setD << endl;
@ -138,6 +140,17 @@ int main(int argc, char *argv[])
// this doesn't work (yet?)
// setD[12] = true;
List<label> someLst(10);
forAll(someLst, elemI)
{
someLst[elemI] = elemI*elemI;
}
label added = setD.set(someLst);
Info<< "added " << added << " from " << someLst.size() << endl;
Info<< "setD : " << setD << endl;
return 0;
}

3
applications/test/HashTable3/hashTableTest3.C
View File

@ -33,7 +33,6 @@ Description
#include "HashPtrTable.H"
#include "Map.H"
#include "StaticHashTable.H"
#include "HashTbl.H"
#include "cpuTime.H"
using namespace Foam;
@ -53,7 +52,7 @@ int main(int argc, char *argv[])
// Map<label> map(2 * nSize);
// HashTable<label, label, Hash<label> > map(2 * nSize);
// StaticHashTable<label, label, Hash<label> > map(2 * nSize);
HashTbl<label, label, Hash<label> > map(2 * nSize);
HashTable<label, label, Hash<label> > map(2 * nSize);
Info<< "Constructed map of size: " << nSize
<< " (size " << map.size() << " capacity " << map.capacity() << ") "

2
applications/test/IndirectList/IndirectListTest.C
View File

@ -72,7 +72,7 @@ int main(int argc, char *argv[])
<< "list: " << idl() << nl
<< endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

2
applications/test/LduMatrix/LduMatrixTest.C
View File

@ -155,7 +155,7 @@ int main(int argc, char *argv[])
Info<< psi << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

2
applications/test/LduMatrix/LduMatrixTest2.C
View File

@ -155,7 +155,7 @@ int main(int argc, char *argv[])
Info<< psi << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

10
applications/test/Map/MapTest.C
View File

@ -53,15 +53,15 @@ int main(int argc, char *argv[])
if (bananaIter == banana.end())
{
Info << "not found" << endl;
Info<< "not found" << endl;
}
else
{
Info << "5 is " << bananaIter() << endl;
Info<< "5 is " << bananaIter() << endl;
}
// Same with STL
Info << "Same with STL" << endl;
Info<< "Same with STL" << endl;
std::map<label, bool> STLbanana;
STLbanana[5] = true;
@ -69,11 +69,11 @@ int main(int argc, char *argv[])
if (STLbananaIter == STLbanana.end())
{
Info << "not found" << endl;
Info<< "not found" << endl;
}
else
{
Info << "5 is " << STLbananaIter->second << endl;
Info<< "5 is " << STLbananaIter->second << endl;
}

16
applications/test/Matrix/MatrixTest.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "Matrix.H"
#include "SquareMatrix.H"
#include "vector.H"
using namespace Foam;
@ -34,7 +34,7 @@ using namespace Foam;
int main(int argc, char *argv[])
{
Matrix<scalar> hmm(3, 3);
SquareMatrix<scalar> hmm(3);
hmm[0][0] = -3.0;
hmm[0][1] = 10.0;
@ -46,32 +46,32 @@ int main(int argc, char *argv[])
hmm[2][1] = 6.0;
hmm[2][2] = 1.0;
Info<< hmm << endl << hmm - 2.0*(-hmm) << endl;
//Info<< hmm << endl << hmm - 2.0*(-hmm) << endl;
Info<< max(hmm) << endl;
Info<< min(hmm) << endl;
Matrix<scalar> hmm2(3, 3, 1.0);
SquareMatrix<scalar> hmm2(3, 1.0);
hmm = hmm2;
Info<< hmm << endl;
Matrix<scalar> hmm3(Sin);
SquareMatrix<scalar> hmm3(Sin);
Info<< hmm3 << endl;
Matrix<scalar> hmm4;
SquareMatrix<scalar> hmm4;
hmm4 = hmm2;
Info<< hmm4 << endl;
Matrix<scalar> hmm5;
SquareMatrix<scalar> hmm5;
hmm4 = hmm5;
Info<< hmm5 << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

2
applications/test/NamedEnum/namedEnumTest.C
View File

@ -68,7 +68,7 @@ int main(int argc, char *argv[])
namedEnumTest::options hmm(namedEnumTest::namedEnum.read(Sin));
Info<< namedEnumTest::namedEnum[hmm] << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

4
applications/test/ODETest/ODETest.C
View File

@ -69,7 +69,7 @@ public:
const scalar x,
const scalarField& y,
scalarField& dfdx,
Matrix<scalar>& dfdy
scalarSquareMatrix& dfdy
) const
{
dfdx[0] = 0.0;
@ -167,7 +167,7 @@ int main(int argc, char *argv[])
Info<< nl << "Analytical: y(2.0) = " << yEnd << endl;
Info << "Numerical: y(2.0) = " << y << ", hEst = " << hEst << endl;
Info << "\nEnd\n" << endl;
Info<< "\nEnd\n" << endl;
return 0;
}

2
applications/test/POSIX/POSIXTest.C
View File

@ -37,7 +37,7 @@ int main(int argc, char *argv[])
{
rmDir("hmm");
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

4
applications/test/PackedList2/PackedListTest2.C
View File

@ -135,7 +135,7 @@ int main(int argc, char *argv[])
sum = 0;
for (label iter = 0; iter < nIters; ++iter)
{
for(unsigned int i = 0; i < stlVector.size(); i++)
for (unsigned int i = 0; i < stlVector.size(); i++)
{
sum += stlVector[i];
}
@ -386,7 +386,7 @@ int main(int argc, char *argv[])
<< " s" << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

4
applications/test/PtrList/PtrListTest.C
View File

@ -54,9 +54,11 @@ public:
~Scalar()
{
Info <<"delete Scalar: " << data_ << endl;
Info<<"delete Scalar: " << data_ << endl;
}
autoPtr<Scalar> clone() const;
friend Ostream& operator<<(Ostream& os, const Scalar& val)
{
os << val.data_;

2
applications/test/Tuple2/Tuple2Test.C
View File

@ -44,7 +44,7 @@ int main()
Info<< t2 << " " << t2.first() << " " << t2.second() << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

10
applications/test/UIndirectListTest/UIndirectListTest.C
View File

@ -84,11 +84,11 @@ int main(int argc, char *argv[])
// test List operations
List<double> flatList = UIndirectList<double>(completeList, addresses);
Info<< "List assigned from UIndirectList: " << flatList << endl;
List<double> flatList(UIndirectList<double>(completeList, addresses));
Info<< "List constructed from UIndirectList: " << flatList << endl;
List<double> flatList2(UIndirectList<double>(completeList, addresses));
Info<< "List constructed from UIndirectList: " << flatList2 << endl;
flatList = UIndirectList<double>(completeList, addresses);
Info<< "List assigned from UIndirectList: " << flatList << endl;
flatList.append(UIndirectList<double>(completeList, addresses));
Info<< "List::append(UIndirectList): " << flatList << endl;
@ -100,7 +100,7 @@ int main(int argc, char *argv[])
dynList.append(UIndirectList<double>(completeList, addresses));
Info<< "DynamicList::append(UIndirectList): " << dynList << endl;
Info << "\nEnd\n" << endl;
Info<< "\nEnd\n" << endl;
return 0;
}

2
applications/test/callback/callbackTest.C
View File

@ -118,7 +118,7 @@ int main(int argc, char *argv[])
cbr.testCallbackFunction();
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

2
applications/test/dimensionedType/dimensionedTypeTest.C
View File

@ -42,7 +42,7 @@ int main(int argc, char *argv[])
Info<< ds*dt << " " << dt*ds << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

16
applications/test/extendedStencil/testExtendedStencil.C
View File

@ -188,11 +188,11 @@ int main(int argc, char *argv[])
// (
// mesh
// );
//
//
// Info<< "cellFaceCell:" << endl;
// writeStencilStats(addressing.stencil());
//
//
//
//
// //// Do some interpolation.
// //{
// // const labelListList& stencil = addressing.stencil();
@ -226,7 +226,7 @@ int main(int argc, char *argv[])
// mesh.C(),
// stencilPoints
// );
//
//
// forAll(stencilPoints, faceI)
// {
// if (stencilPoints[faceI].size() >= 15)
@ -443,10 +443,10 @@ int main(int argc, char *argv[])
(
mesh
);
Info<< "cellFaceCell:" << endl;
writeStencilStats(addressing.stencil());
// Collect stencil face centres
List<List<point> > stencilPoints(mesh.nCells());
addressing.collectData
@ -454,7 +454,7 @@ int main(int argc, char *argv[])
mesh.Cf(),
stencilPoints
);
forAll(stencilPoints, cellI)
{
writeStencilOBJ
@ -477,7 +477,7 @@ int main(int argc, char *argv[])
// vf,
// stencilData
// );
// for(label faci = 0; faci < mesh.nInternalFaces(); faci++)
// for (label faci = 0; faci < mesh.nInternalFaces(); faci++)
// {
// const scalarList& stData = stencilData[faceI];
// const scalarList& stWeight = fit[faceI];

3
applications/test/fileName/fileNameTest.C
View File

@ -108,8 +108,7 @@ int main()
Info<< " badName(die) => " << findEtcFile("badName", true) << nl
<< endl;
Info<< "\nEnd" << endl;
Info<< "\nEnd\n" << endl;
return 0;
}

3
applications/test/fileNameClean/fileNameCleanTest.C
View File

@ -95,8 +95,7 @@ int main(int argc, char *argv[])
printCleaning(pathName);
}
Info<< "\nEnd" << endl;
Info<< "\nEnd\n" << endl;
return 0;
}

2
applications/test/liquid/liquidTest.C
View File

@ -39,7 +39,7 @@ int main()
Info<< fuel.rho(1e5, 300) << endl;
Info<< fuel << endl;
Info << "End\n" << endl;
Info<< "End\n" << endl;
return 0;
}

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