zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

coupledMultiphaseTemperatureFvPatchScalarField: New BC for multiphase CHT cases

Browse Source 
Class
    Foam::coupledMultiphaseTemperatureFvPatchScalarField

Description
    Mixed boundary condition for the phase temperature of a phase in an
    Euler-Euler multiphase simulation, to be used for heat-transfer with another
    region in a CHT case.  Optional thin wall material layer resistances can be
    specified through thicknessLayers and kappaLayers entries.

See also
    Foam::coupledTemperatureFvPatchScalarField

The new tutorial case tutorials/modules/CHT/multiphaseCoolingCylinder2D is a
variant of the coolingCylinder2D case in which a 10% oil droplets in water
mixture flows over and cools a hot cylinder.  The case in run with the
foamMultiRun multi-solver executor.
This commit is contained in:
Henry Weller
2022-11-15 16:56:56 +00:00
parent 5c0265beb5
commit a7d40a4fe5
47 changed files with 2478 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
applications/solvers/modules/fluid/multiphaseEuler/multiphaseThermophysicalTransportModels/Make/files
View File

@ -26,5 +26,6 @@ derivedFvPatchFields/alphatFixedDmdtfWallBoilingWallFunction/alphatFixedDmdtfWal
derivedFvPatchFields/alphatWallBoilingWallFunction/alphatWallBoilingWallFunctionFvPatchScalarField.C derivedFvPatchFields/alphatWallBoilingWallFunction/alphatWallBoilingWallFunctionFvPatchScalarField.C
derivedFvPatchFields/copiedFixedValue/copiedFixedValueFvPatchScalarField.C derivedFvPatchFields/copiedFixedValue/copiedFixedValueFvPatchScalarField.C
derivedFvPatchFields/fixedMultiphaseHeatFlux/fixedMultiphaseHeatFluxFvPatchScalarField.C derivedFvPatchFields/fixedMultiphaseHeatFlux/fixedMultiphaseHeatFluxFvPatchScalarField.C
derivedFvPatchFields/coupledMultiphaseTemperature/coupledMultiphaseTemperatureFvPatchScalarField.C
LIB = $(FOAM_LIBBIN)/libmultiphaseThermophysicalTransportModels LIB = $(FOAM_LIBBIN)/libmultiphaseThermophysicalTransportModels

9
applications/solvers/modules/fluid/multiphaseEuler/multiphaseThermophysicalTransportModels/Make/options
View File

@ -9,12 +9,15 @@ EXE_INC = \
-I$(LIB_SRC)/MomentumTransportModels/momentumTransportModels/lnInclude \ -I$(LIB_SRC)/MomentumTransportModels/momentumTransportModels/lnInclude \
-I$(LIB_SRC)/MomentumTransportModels/compressible/lnInclude \ -I$(LIB_SRC)/MomentumTransportModels/compressible/lnInclude \
-I$(LIB_SRC)/MomentumTransportModels/phaseCompressible/lnInclude \ -I$(LIB_SRC)/MomentumTransportModels/phaseCompressible/lnInclude \
-I$(LIB_SRC)/ThermophysicalTransportModels/thermophysicalTransportModel/lnInclude \
-I$(LIB_SRC)/ThermophysicalTransportModels/coupledThermophysicalTransportModels/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \ -I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \ -I$(LIB_SRC)/meshTools/lnInclude
-I$(LIB_SRC)/sampling/lnInclude
LIB_LIBS = \ LIB_LIBS = \
-lphaseSystem \ -lphaseSystem \
-leulerianInterfacialModels \ -leulerianInterfacialModels \
-leulerianInterfacialCompositionModels \ -leulerianInterfacialCompositionModels \
-lphaseCompressibleMomentumTransportModels -lphaseCompressibleMomentumTransportModels \
-lphaseFluidMulticomponentThermophysicalTransportModels \
-lcoupledThermophysicalTransportModels

196
applications/solvers/modules/fluid/multiphaseEuler/multiphaseThermophysicalTransportModels/derivedFvPatchFields/coupledMultiphaseTemperature/coupledMultiphaseTemperatureFvPatchScalarField.C Normal file
View File

@ -0,0 +1,196 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "coupledMultiphaseTemperatureFvPatchScalarField.H"
#include "fvPatchFieldMapper.H"
#include "phaseSystem.H"
#include "compressibleMomentumTransportModels.H"
#include "phaseCompressibleMomentumTransportModel.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
void Foam::coupledMultiphaseTemperatureFvPatchScalarField::getThis
(
tmp<scalarField>& kappa,
tmp<scalarField>& sumKappaTByDelta,
tmp<scalarField>& sumKappaByDelta,
scalarField& sumq,
tmp<scalarField>& qByKappa
) const
{
// Lookup the fluid model
const phaseSystem& fluid =
patch().boundaryMesh().mesh()
.lookupObject<phaseSystem>(phaseSystem::propertiesName);
scalarField sumKappa(size(), scalar(0));
scalarField sumKappaT(size(), scalar(0));
forAll(fluid.phases(), phasei)
{
const phaseModel& phase = fluid.phases()[phasei];
const fluidThermo& thermo = phase.thermo();
const fvPatchScalarField& Tw =
thermo.T().boundaryField()[patch().index()];
const fvPatchScalarField& alpha =
phase.boundaryField()[patch().index()];
tmp<scalarField> kappaEff(phase.kappaEff(patch().index()));
tmp<scalarField> alphaKappaEff(alpha*kappaEff());
if (&Tw == this)
{
kappa = alphaKappaEff;
qByKappa = sumq/kappaEff;
sumq -= alpha*sumq;
}
else
{
const scalarField T =
thermo.T().boundaryField()[patch().index()]
.patchInternalField();
sumKappa += alphaKappaEff();
sumKappaT += alphaKappaEff*T;
}
}
sumKappaByDelta = sumKappa*patch().deltaCoeffs();
sumKappaTByDelta = sumKappaT*patch().deltaCoeffs();
}
void Foam::coupledMultiphaseTemperatureFvPatchScalarField::getNbr
(
tmp<scalarField>& sumKappaTByDeltaNbr,
tmp<scalarField>& sumKappaByDeltaNbr,
tmp<scalarField>& qNbr
) const
{
// Lookup the fluid model
const phaseSystem& fluid =
patch().boundaryMesh().mesh()
.lookupObject<phaseSystem>(phaseSystem::propertiesName);
scalarField sumKappa(size(), scalar(0));
scalarField sumKappaT(size(), scalar(0));
forAll(fluid.phases(), phasei)
{
const phaseModel& phase = fluid.phases()[phasei];
const fluidThermo& thermo = phase.thermo();
const fvPatchScalarField& alpha =
phase.boundaryField()[patch().index()];
const scalarField T =
thermo.T().boundaryField()[patch().index()].patchInternalField();
const scalarField alphaKappaEff(alpha*phase.kappaEff(patch().index()));
sumKappa += alphaKappaEff;
sumKappaT += alphaKappaEff*T;
}
sumKappaByDeltaNbr = sumKappa*patch().deltaCoeffs();
sumKappaTByDeltaNbr = sumKappaT*patch().deltaCoeffs();
}
void Foam::coupledMultiphaseTemperatureFvPatchScalarField::getNbr
(
tmp<scalarField>& TrefNbr,
tmp<scalarField>& qNbr
) const
{
NotImplemented;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::coupledMultiphaseTemperatureFvPatchScalarField::
coupledMultiphaseTemperatureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF
)
:
coupledTemperatureFvPatchScalarField(p, iF)
{}
Foam::coupledMultiphaseTemperatureFvPatchScalarField::
coupledMultiphaseTemperatureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
coupledTemperatureFvPatchScalarField(p, iF, dict)
{}
Foam::coupledMultiphaseTemperatureFvPatchScalarField::
coupledMultiphaseTemperatureFvPatchScalarField
(
const coupledMultiphaseTemperatureFvPatchScalarField& psf,
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
coupledTemperatureFvPatchScalarField(psf, p, iF, mapper)
{}
Foam::coupledMultiphaseTemperatureFvPatchScalarField::
coupledMultiphaseTemperatureFvPatchScalarField
(
const coupledMultiphaseTemperatureFvPatchScalarField& psf,
const DimensionedField<scalar, volMesh>& iF
)
:
coupledTemperatureFvPatchScalarField(psf, iF)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makePatchTypeField
(
fvPatchScalarField,
coupledMultiphaseTemperatureFvPatchScalarField
);
}
// ************************************************************************* //

161
applications/solvers/modules/fluid/multiphaseEuler/multiphaseThermophysicalTransportModels/derivedFvPatchFields/coupledMultiphaseTemperature/coupledMultiphaseTemperatureFvPatchScalarField.H Normal file
View File

@ -0,0 +1,161 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::coupledMultiphaseTemperatureFvPatchScalarField
Description
Mixed boundary condition for the phase temperature of a phase in an
Euler-Euler multiphase simulation, to be used for heat-transfer with another
region in a CHT case. Optional thin wall material layer resistances can be
specified through thicknessLayers and kappaLayers entries.
See also
Foam::coupledTemperatureFvPatchScalarField
SourceFiles
coupledMultiphaseTemperatureFvPatchScalarField.C
\*---------------------------------------------------------------------------*/
#ifndef coupledMultiphaseTemperatureFvPatchScalarField_H
#define coupledMultiphaseTemperatureFvPatchScalarField_H
#include "coupledTemperatureFvPatchScalarField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class coupledMultiphaseTemperatureFvPatchScalarField Declaration
\*---------------------------------------------------------------------------*/
class coupledMultiphaseTemperatureFvPatchScalarField
:
public coupledTemperatureFvPatchScalarField
{
protected:
//- Get the patch kappa, sum kappa*Tc/delta and kappa/delta for all phases
// except the phase being solved and also the phase heat-flux obtained by
// partitioning the sum heat-flux provided
virtual void getThis
(
tmp<scalarField>& kappa,
tmp<scalarField>& sumKappaTByDelta,
tmp<scalarField>& sumKappaByDelta,
scalarField& sumq,
tmp<scalarField>& qByKappa
) const;
//- Get the neighbour patch sum kappa*Tc/delta and kappa/delta
// for all phases and the heat-flux correction
virtual void getNbr
(
tmp<scalarField>& sumKappaTByDeltaNbr,
tmp<scalarField>& sumKappaByDeltaNbr,
tmp<scalarField>& qNbr
) const;
//- Get the neighbour patch wall temperature and heat-flux
// when wall thermal resistance is specified
virtual void getNbr
(
tmp<scalarField>& TwNbr,
tmp<scalarField>& qNbr
) const;
public:
//- Runtime type information
TypeName("coupledMultiphaseTemperature");
// Constructors
//- Construct from patch and internal field
coupledMultiphaseTemperatureFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&
);
//- Construct from patch, internal field and dictionary
coupledMultiphaseTemperatureFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const dictionary&
);
//- Construct by mapping given
// coupledMultiphaseTemperatureFvPatchScalarField
// onto a new patch
coupledMultiphaseTemperatureFvPatchScalarField
(
const coupledMultiphaseTemperatureFvPatchScalarField&,
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const fvPatchFieldMapper&
);
//- Disallow copy without setting internal field reference
coupledMultiphaseTemperatureFvPatchScalarField
(
const coupledMultiphaseTemperatureFvPatchScalarField&
) = delete;
//- Copy constructor setting internal field reference
coupledMultiphaseTemperatureFvPatchScalarField
(
const coupledMultiphaseTemperatureFvPatchScalarField&,
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 coupledMultiphaseTemperatureFvPatchScalarField(*this, iF)
);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

240
src/ThermophysicalTransportModels/coupledThermophysicalTransportModels/coupledTemperature/coupledTemperatureFvPatchScalarField.C
View File

@ -30,6 +30,101 @@ License
#include "mappedPatchBase.H" #include "mappedPatchBase.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
void Foam::coupledTemperatureFvPatchScalarField::getThis
(
tmp<scalarField>& kappa,
tmp<scalarField>& sumKappaTByDelta,
tmp<scalarField>& sumKappaByDeltaNbr,
scalarField& sumq,
tmp<scalarField>& qByKappa
) const
{
const thermophysicalTransportModel& ttm =
patch().boundaryMesh().mesh()
.lookupType<thermophysicalTransportModel>();
kappa = ttm.kappaEff(patch().index());
qByKappa = sumq/kappa;
sumq = 0;
tmp<scalarField> qCorr(ttm.qCorr(patch().index()));
if (qCorr.valid())
{
sumq += qCorr;
}
}
void Foam::coupledTemperatureFvPatchScalarField::getNbr
(
tmp<scalarField>& sumKappaTByDeltaNbr,
tmp<scalarField>& sumKappaByDeltaNbr,
tmp<scalarField>& qNbr
) const
{
const thermophysicalTransportModel& ttm =
patch().boundaryMesh().mesh()
.lookupType<thermophysicalTransportModel>();
sumKappaByDeltaNbr = ttm.kappaEff(patch().index())*patch().deltaCoeffs();
sumKappaTByDeltaNbr = sumKappaByDeltaNbr()*patchInternalField();
qNbr = ttm.qCorr(patch().index());
}
void Foam::coupledTemperatureFvPatchScalarField::getNbr
(
tmp<scalarField>& TrefNbr,
tmp<scalarField>& qNbr
) const
{
const thermophysicalTransportModel& ttm =
patch().boundaryMesh().mesh()
.lookupType<thermophysicalTransportModel>();
const fvPatchScalarField& Tp =
patch().lookupPatchField<volScalarField, scalar>
(
internalField().name()
);
TrefNbr = Tp;
qNbr = ttm.qCorr(patch().index());
}
void Foam::coupledTemperatureFvPatchScalarField::add
(
tmp<scalarField>& result,
const tmp<scalarField>& field
) const
{
if (result.valid())
{
result.ref() += field;
}
else
{
if (field.isTmp())
{
result = field;
}
else
{
result = field().clone();
}
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::coupledTemperatureFvPatchScalarField:: Foam::coupledTemperatureFvPatchScalarField::
@ -46,11 +141,11 @@ coupledTemperatureFvPatchScalarField
thicknessLayers_(0), thicknessLayers_(0),
kappaLayers_(0), kappaLayers_(0),
qs_(p.size()), qs_(p.size()),
contactRes_(0) wallKappaByDelta_(0)
{ {
this->refValue() = 0.0; this->refValue() = 0;
this->refGrad() = 0.0; this->refGrad() = 0;
this->valueFraction() = 1.0; this->valueFraction() = 1;
} }
@ -69,7 +164,7 @@ coupledTemperatureFvPatchScalarField
thicknessLayers_(0), thicknessLayers_(0),
kappaLayers_(0), kappaLayers_(0),
qs_(p.size(), 0), qs_(p.size(), 0),
contactRes_(0.0) wallKappaByDelta_(0)
{ {
if (!isA<mappedPatchBase>(this->patch().patch())) if (!isA<mappedPatchBase>(this->patch().patch()))
{ {
@ -89,11 +184,11 @@ coupledTemperatureFvPatchScalarField
if (thicknessLayers_.size() > 0) if (thicknessLayers_.size() > 0)
{ {
// Calculate effective thermal resistance by harmonic averaging // Calculate effective thermal resistance by harmonic averaging
forAll(thicknessLayers_, iLayer) forAll(thicknessLayers_, i)
{ {
contactRes_ += thicknessLayers_[iLayer]/kappaLayers_[iLayer]; wallKappaByDelta_ += thicknessLayers_[i]/kappaLayers_[i];
} }
contactRes_ = 1.0/contactRes_; wallKappaByDelta_ = 1/wallKappaByDelta_;
} }
} }
@ -130,8 +225,8 @@ coupledTemperatureFvPatchScalarField
{ {
// Start from user entered data. Assume fixedValue. // Start from user entered data. Assume fixedValue.
refValue() = *this; refValue() = *this;
refGrad() = 0.0; refGrad() = 0;
valueFraction() = 1.0; valueFraction() = 1;
} }
} }
@ -152,7 +247,7 @@ coupledTemperatureFvPatchScalarField
thicknessLayers_(psf.thicknessLayers_), thicknessLayers_(psf.thicknessLayers_),
kappaLayers_(psf.kappaLayers_), kappaLayers_(psf.kappaLayers_),
qs_(mapper(psf.qs_)), qs_(mapper(psf.qs_)),
contactRes_(psf.contactRes_) wallKappaByDelta_(psf.wallKappaByDelta_)
{} {}
@ -170,7 +265,7 @@ coupledTemperatureFvPatchScalarField
thicknessLayers_(psf.thicknessLayers_), thicknessLayers_(psf.thicknessLayers_),
kappaLayers_(psf.kappaLayers_), kappaLayers_(psf.kappaLayers_),
qs_(psf.qs_), qs_(psf.qs_),
contactRes_(psf.contactRes_) wallKappaByDelta_(psf.wallKappaByDelta_)
{} {}
@ -188,8 +283,6 @@ void Foam::coupledTemperatureFvPatchScalarField::updateCoeffs()
int oldTag = UPstream::msgType(); int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1; UPstream::msgType() = oldTag + 1;
const label patchi = patch().index();
// Get the coupling information from the mappedPatchBase // Get the coupling information from the mappedPatchBase
const mappedPatchBase& mpp = const mappedPatchBase& mpp =
refCast<const mappedPatchBase>(patch().patch()); refCast<const mappedPatchBase>(patch().patch());
@ -197,109 +290,93 @@ void Foam::coupledTemperatureFvPatchScalarField::updateCoeffs()
const fvPatch& patchNbr = const fvPatch& patchNbr =
refCast<const fvMesh>(mpp.nbrMesh()).boundary()[patchiNbr]; refCast<const fvMesh>(mpp.nbrMesh()).boundary()[patchiNbr];
// Calculate the temperature by harmonic averaging
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
typedef coupledTemperatureFvPatchScalarField thisType;
const fvPatchScalarField& TpNbr = const fvPatchScalarField& TpNbr =
patchNbr.lookupPatchField<volScalarField, scalar>(TnbrName_); patchNbr.lookupPatchField<volScalarField, scalar>(TnbrName_);
if (!isA<thisType>(TpNbr)) if (!isA<coupledTemperatureFvPatchScalarField>(TpNbr))
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Patch field for " << internalField().name() << " on " << "Patch field for " << internalField().name() << " on "
<< patch().name() << " is of type " << thisType::typeName << this->patch().name() << " is of type "
<< endl << "The neighbouring patch field " << TnbrName_ << " on " << coupledTemperatureFvPatchScalarField::typeName
<< endl << "The neighbouring patch field "
<< internalField().name() << " on "
<< patchNbr.name() << " is required to be the same, but is " << patchNbr.name() << " is required to be the same, but is "
<< "currently of type " << TpNbr.type() << exit(FatalError); << "currently of type " << TpNbr.type() << exit(FatalError);
} }
const thisType& coupledTemperatureNbr = refCast<const thisType>(TpNbr); const coupledTemperatureFvPatchScalarField& coupledTemperatureNbr =
refCast<const coupledTemperatureFvPatchScalarField>(TpNbr);
const scalarField TcNbr scalarField sumq(qs_);
(
contactRes_ == 0
? mpp.distribute(coupledTemperatureNbr.patchInternalField())
: mpp.distribute(coupledTemperatureNbr)
);
const thermophysicalTransportModel& ttm =
patch().boundaryMesh().mesh()
.lookupType<thermophysicalTransportModel>();
const thermophysicalTransportModel& ttmNbr =
patchNbr.boundaryMesh().mesh()
.lookupType<thermophysicalTransportModel>();
const scalarField kappa(ttm.kappaEff(patchi));
const scalarField kappaByDelta(kappa*patch().deltaCoeffs());
const scalarField kappaByDeltaNbr
(
contactRes_ == 0
? mpp.distribute
(
ttmNbr.kappaEff(patchiNbr)*patchNbr.deltaCoeffs()
)
: tmp<scalarField>(new scalarField(size(), contactRes_))
);
scalarField qTot(qs_);
if (qrName_ != "none") if (qrName_ != "none")
{ {
qTot += patch().lookupPatchField<volScalarField, scalar>(qrName_); sumq += patch().lookupPatchField<volScalarField, scalar>(qrName_);
} }
if (qrNbrName_ != "none") if (qrNbrName_ != "none")
{ {
qTot += mpp.distribute sumq += mpp.distribute
( (
patchNbr.lookupPatchField<volScalarField, scalar>(qrNbrName_) patchNbr.lookupPatchField<volScalarField, scalar>(qrNbrName_)
); );
} }
tmp<scalarField> qCorr(ttm.qCorr(patchi)); tmp<scalarField> kappa;
tmp<scalarField> sumKappaTByDelta;
tmp<scalarField> sumKappaByDelta;
tmp<scalarField> qByKappa;
if (qCorr.valid()) // q = alpha.this*sumq
getThis(kappa, sumKappaTByDelta, sumKappaByDelta, sumq, qByKappa);
// Add neighbour contributions
{ {
qTot += qCorr; tmp<scalarField> sumKappaTByDeltaNbr;
tmp<scalarField> sumKappaByDeltaNbr;
tmp<scalarField> qNbr;
if (wallKappaByDelta_ == 0)
{
coupledTemperatureNbr.getNbr
(
sumKappaTByDeltaNbr,
sumKappaByDeltaNbr,
qNbr
);
add(sumKappaTByDelta, mpp.distribute(sumKappaTByDeltaNbr));
add(sumKappaByDelta, mpp.distribute(sumKappaByDeltaNbr));
}
else
{
// Get the neighbour wall temperature and flux correction
tmp<scalarField> TwNbr;
coupledTemperatureNbr.getNbr(TwNbr, qNbr);
add(sumKappaByDelta, scalarField(size(), wallKappaByDelta_));
add(sumKappaTByDelta, wallKappaByDelta_*mpp.distribute(TwNbr));
} }
tmp<scalarField> qCorrNbr(ttmNbr.qCorr(patchiNbr)); if (qNbr.valid())
if (qCorrNbr.valid())
{ {
qTot += mpp.distribute(qCorrNbr); sumq += mpp.distribute(qNbr);
}
} }
// Both sides agree on this->valueFraction() =
// - temperature : (kappaByDelta*fld + kappaByDeltaNbr*nbrFld) sumKappaByDelta()/(kappa()*patch().deltaCoeffs() + sumKappaByDelta());
// /(kappaByDelta + kappaByDeltaNbr)
// - gradient : (temperature - fld)*delta
// We've got a degree of freedom in how to implement this in a mixed bc.
// (what gradient, what fixedValue and mixing coefficient)
// Two reasonable choices:
// 1. specify above temperature on one side (preferentially the high side)
// and above gradient on the other. So this will switch between pure
// fixedValue and pure fixedGradient
// 2. specify gradient and temperature such that the equations are the
// same on both sides. This leads to the choice of
// - refGradient = qTot/kappa;
// - refValue = neighbour value
// - mixFraction = kappaByDeltaNbr / (kappaByDeltaNbr + kappaByDelta)
this->valueFraction() = kappaByDeltaNbr/(kappaByDeltaNbr + kappaByDelta); this->refValue() = (sumKappaTByDelta() + sumq)/sumKappaByDelta();
this->refValue() = TcNbr;
this->refGrad() = qTot/kappa; this->refGrad() = qByKappa;
mixedFvPatchScalarField::updateCoeffs(); mixedFvPatchScalarField::updateCoeffs();
if (debug) if (debug)
{ {
scalar Q = gSum(kappa*patch().magSf()*snGrad()); const scalar Q = gSum(kappa()*patch().magSf()*snGrad());
Info<< patch().boundaryMesh().mesh().name() << ':' Info<< patch().boundaryMesh().mesh().name() << ':'
<< patch().name() << ':' << patch().name() << ':'
@ -326,7 +403,6 @@ void Foam::coupledTemperatureFvPatchScalarField::write
) const ) const
{ {
mixedFvPatchScalarField::write(os); mixedFvPatchScalarField::write(os);
writeEntry(os, "Tnbr", TnbrName_);
writeEntry(os, "qrNbr", qrNbrName_); writeEntry(os, "qrNbr", qrNbrName_);
writeEntry(os, "qr", qrName_); writeEntry(os, "qr", qrName_);
writeEntry(os, "thicknessLayers", thicknessLayers_); writeEntry(os, "thicknessLayers", thicknessLayers_);

58
src/ThermophysicalTransportModels/coupledThermophysicalTransportModels/coupledTemperature/coupledTemperatureFvPatchScalarField.H
View File

@ -26,14 +26,15 @@ Class
Description Description
Mixed boundary condition for temperature, to be used for heat-transfer Mixed boundary condition for temperature, to be used for heat-transfer
on back-to-back baffles. Optional thin thermal layer resistances can be with another region in a CHT case. Optional thin wall material layer
specified through thicknessLayers and kappaLayers entries. resistances can be specified through thicknessLayers and kappaLayers
entries.
Specifies gradient and temperature such that the equations are the same Specifies gradient and temperature such that the equations are the same
on both sides: on both sides:
- refGradient = qs_/kappa - refGradient = qs_/kappa
- refValue = neighbour value - refValue = neighbour value
- mixFraction = kappaByDeltaNbr/(kappaByDeltaNbr + kappaByDelta()) - valueFraction = kappaByDeltaNbr/(kappaByDeltaNbr + kappaByDelta)
where kappaByDelta is heat-transfer coefficient kappa*deltaCoeffs where kappaByDelta is heat-transfer coefficient kappa*deltaCoeffs
and qs is the optional source heat flux. and qs is the optional source heat flux.
@ -55,9 +56,8 @@ Usage
<patchName> <patchName>
{ {
type coupledTemperature; type coupledTemperature;
Tnbr T; thicknessLayers (0.1 0.2 0.3 0.4); // Optional wall layer thicknesses
thicknessLayers (0.1 0.2 0.3 0.4); kappaLayers (1 2 3 4); // Optional wall layer conductivities
kappaLayers (1 2 3 4);
qs uniform 100; // Optional source heat flux [W/m^2] qs uniform 100; // Optional source heat flux [W/m^2]
value uniform 300; value uniform 300;
} }
@ -107,17 +107,55 @@ class coupledTemperatureFvPatchScalarField
//- Name of the radiative heat flux in local region //- Name of the radiative heat flux in local region
const word qrName_; const word qrName_;
//- Thickness of layers //- Thickness of wall layers
scalarList thicknessLayers_; scalarList thicknessLayers_;
//- Conductivity of layers //- Conductivity of wall layers
scalarList kappaLayers_; scalarList kappaLayers_;
//- Source heat flux [W/m^2] //- Source heat flux [W/m^2]
scalarField qs_; scalarField qs_;
//- Total contact resistance //- Optional wall material conductivity/thickness
scalar contactRes_; scalar wallKappaByDelta_;
protected:
//- Get the patch kappa, kappa*Tc/delta and kappa/delta and also the
// heat-flux obtained from the sum heat-flux provided
virtual void getThis
(
tmp<scalarField>& kappa,
tmp<scalarField>& sumKappaTByDelta,
tmp<scalarField>& sumKappaByDelta,
scalarField& qTot,
tmp<scalarField>& qByKappa
) const;
//- Get the neighbour patch kappa*Tc/delta and kappa/delta
// and the heat-flux correction
virtual void getNbr
(
tmp<scalarField>& sumKappaTByDeltaNbr,
tmp<scalarField>& sumKappaByDeltaNbr,
tmp<scalarField>& qNbr
) const;
//- Get the neighbour patch wall temperature and heat-flux
// when wall thermal resistance is specified
virtual void getNbr
(
tmp<scalarField>& TwNbr,
tmp<scalarField>& qNbr
) const;
//- Add field to result which may have not been previously set
void add
(
tmp<scalarField>& result,
const tmp<scalarField>& field
) const;
public: public:

2
tutorials/modules/CHT/coolingCylinder2D/0/fluid/T
View File

@ -40,8 +40,6 @@ boundaryField
wall wall
{ {
type coupledTemperature; type coupledTemperature;
thicknessLayers (1e-3);
kappaLayers (1e-3);
value $internalField; value $internalField;
} }

2
tutorials/modules/CHT/coolingCylinder2D/0/solid/T
View File

@ -22,8 +22,6 @@ boundaryField
wall wall
{ {
type coupledTemperature; type coupledTemperature;
thicknessLayers (1e-3);
kappaLayers (1e-3);
value $internalField; value $internalField;
} }
} }

3
tutorials/modules/CHT/coolingCylinder2D/system/controlDict
View File

@ -73,8 +73,7 @@ functions
patch=inlet, patch=inlet,
field=U field=U
) )
}
} }
// ************************************************************************* // // ************************************************************************* //

13
tutorials/modules/CHT/coolingCylinder2D/system/fluid/fvSolution
View File

@ -1,4 +1,4 @@
/*--------------------------------*- C++ -*----------------------------------*\ /*--------------------------------*- C++ -*----------------------------------*\
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org \\ / O peration | Website: https://openfoam.org
@ -17,20 +17,16 @@ solvers
{ {
"(rho|rhoFinal)" "(rho|rhoFinal)"
{ {
solver PCG solver diagonal;
preconditioner DIC;
tolerance 1e-7;
relTol 0;
} }
p_rgh p_rgh
{ {
solver GAMG; solver GAMG;
tolerance 1e-7;
relTol 0.01;
smoother GaussSeidel; smoother GaussSeidel;
tolerance 1e-7;
relTol 0.01;
maxIter 100; maxIter 100;
} }
@ -39,6 +35,7 @@ solvers
{ {
solver PBiCGStab; solver PBiCGStab;
preconditioner DILU; preconditioner DILU;
tolerance 1e-6; tolerance 1e-6;
relTol 0.1; relTol 0.1;
} }

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/T.oil Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object T.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 297;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.oil;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type coupledMultiphaseTemperature;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/T.water Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object T.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 1 0 0 0];
internalField uniform 297;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.water;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type coupledMultiphaseTemperature;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

48
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/U.oil Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format binary;
class volVectorField;
object U.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0.1 0 0);
boundaryField
{
inlet
{
type fixedValue;
value uniform (0.1 0 0);
}
outlet
{
type pressureInletOutletVelocity;
phi phi.oil;
value $internalField;
}
topAndBottom
{
type slip;
}
wall
{
type noSlip;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

48
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/U.water Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format binary;
class volVectorField;
object U.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField uniform (0.1 0 0);
boundaryField
{
inlet
{
type fixedValue;
value uniform (0.1 0 0);
}
outlet
{
type pressureInletOutletVelocity;
phi phi.water;
value $internalField;
}
topAndBottom
{
type slip;
}
wall
{
type noSlip;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/alpha.oil Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
location "0";
object alpha.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0.1;
boundaryField
{
inlet
{
type fixedValue;
value uniform 0.1;
}
outlet
{
type inletOutlet;
phi phi.oil;
inletValue uniform 0.1;
value uniform 0.1;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type zeroGradient;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

49
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/alpha.water Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object alpha.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 0 0 0 0 0 0];
internalField uniform 0.9;
boundaryField
{
inlet
{
type fixedValue;
value uniform 0.9;
}
outlet
{
type inletOutlet;
phi phi.water;
inletValue uniform 0.9;
value uniform 0.9;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type zeroGradient;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

49
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/alphat.oil Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object alphat.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type compressible::alphatWallFunction;
Prt 0.85;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

49
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/alphat.water Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object alphat.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type compressible::alphatWallFunction;
Prt 0.85;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/epsilon.oil Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object epsilon.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -3 0 0 0 0];
internalField uniform 1.5e-4;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.oil;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type epsilonWallFunction;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/epsilon.water Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object epsilon.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -3 0 0 0 0];
internalField uniform 1.5e-4;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.water;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type epsilonWallFunction;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

51
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/epsilonm Normal file
View File

@ -0,0 +1,51 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object epsilonm;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -3 0 0 0 0];
internalField uniform 1.5e-4;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phim;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type epsilonmWallFunction;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/k.oil Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object k.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 3.75e-5;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.oil;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type kqRWallFunction;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/k.water Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object k.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 3.75e-5;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phi.water;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type kqRWallFunction;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

50
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/km Normal file
View File

@ -0,0 +1,50 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object km;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 3.75e-5;
boundaryField
{
inlet
{
type fixedValue;
value $internalField;
}
outlet
{
type inletOutlet;
phi phim;
inletValue $internalField;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type zeroGradient;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

42
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/nut Normal file
View File

@ -0,0 +1,42 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object nut;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 0;
boundaryField
{
"(inlet|outlet)"
{
type calculated;
value uniform 0;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type nutkWallFunction;
value uniform 0;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

48
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/nut.oil Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object nut.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 1e-8;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type nutkWallFunction;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

48
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/nut.water Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object nut.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -1 0 0 0 0];
internalField uniform 1e-8;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type nutkWallFunction;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

48
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/p Normal file
View File

@ -0,0 +1,48 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField uniform 1e5;
boundaryField
{
inlet
{
type calculated;
value $internalField;
}
outlet
{
type calculated;
value $internalField;
}
topAndBottom
{
type zeroGradient;
}
wall
{
type calculated;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

49
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/fluid/p_rgh Normal file
View File

@ -0,0 +1,49 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object p_rgh;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField uniform 1e5;
boundaryField
{
inlet
{
type fixedFluxPressure;
value $internalField;
}
outlet
{
type prghPressure;
p $internalField;
value $internalField;
}
topAndBottom
{
type fixedFluxPressure;
}
wall
{
type fixedFluxPressure;
value $internalField;
}
#includeEtc "caseDicts/setConstraintTypes"
}
// ************************************************************************* //

30
tutorials/modules/CHT/multiphaseCoolingCylinder2D/0/solid/T Normal file
View File

@ -0,0 +1,30 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class volScalarField;
object T;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [ 0 0 0 1 0 0 0 ];
internalField uniform 350;
boundaryField
{
wall
{
type coupledTemperature;
Tnbr T.water;
value $internalField;
}
}
// ************************************************************************* //

16
tutorials/modules/CHT/multiphaseCoolingCylinder2D/Allrun Executable file
View File

@ -0,0 +1,16 @@
#!/bin/sh
cd ${0%/*} || exit 1 # Run from this directory
# Source tutorial run functions
. $WM_PROJECT_DIR/bin/tools/RunFunctions
runApplication blockMesh
runApplication splitMeshRegions -cellZones -overwrite
paraFoam -region fluid -touch
paraFoam -region solid -touch
runApplication $(getApplication)
#------------------------------------------------------------------------------

21
tutorials/modules/CHT/multiphaseCoolingCylinder2D/constant/fluid/g Normal file
View File

@ -0,0 +1,21 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class uniformDimensionedVectorField;
location "constant";
object g;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -2 0 0 0 0];
value (0 0 0);
// ************************************************************************* //

27
tutorials/modules/CHT/multiphaseCoolingCylinder2D/constant/fluid/momentumTransport.oil Normal file
View File

@ -0,0 +1,27 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
location "constant";
object momentumTransport.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType RAS;
RAS
{
model mixtureKEpsilon;
turbulence on;
printCoeffs on;
}
// ************************************************************************* //

27
tutorials/modules/CHT/multiphaseCoolingCylinder2D/constant/fluid/momentumTransport.water Normal file
View File

@ -0,0 +1,27 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
location "constant";
object momentumTransport.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
simulationType RAS;
RAS
{
model mixtureKEpsilon;
turbulence on;
printCoeffs on;
}
// ************************************************************************* //

143
tutorials/modules/CHT/multiphaseCoolingCylinder2D/constant/fluid/phaseProperties Normal file
View File

@ -0,0 +1,143 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
location "constant";
object phaseProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
type basicMultiphaseSystem;
phases (oil water);
oil
{
type purePhaseModel;
diameterModel isothermal;
isothermalCoeffs
{
d0 3e-3;
p0 1e5;
}
residualAlpha 1e-6;
}
water
{
type purePhaseModel;
diameterModel constant;
constantCoeffs
{
d 1e-4;
}
residualAlpha 1e-6;
}
blending
{
default
{
type linear;
minFullyContinuousAlpha.oil 0.7;
minPartlyContinuousAlpha.oil 0.3;
minFullyContinuousAlpha.water 0.7;
minPartlyContinuousAlpha.water 0.3;
}
drag
{
type linear;
minFullyContinuousAlpha.oil 0.7;
minPartlyContinuousAlpha.oil 0.5;
minFullyContinuousAlpha.water 0.7;
minPartlyContinuousAlpha.water 0.5;
}
}
surfaceTension
{
oil_water
{
type constant;
sigma 0.07;
}
}
drag
{
oil_dispersedIn_water
{
type SchillerNaumann;
residualRe 1e-3;
}
water_dispersedIn_oil
{
type SchillerNaumann;
residualRe 1e-3;
}
oil_segregatedWith_water
{
type segregated;
m 0.5;
n 8;
}
}
virtualMass
{
oil_dispersedIn_water
{
type constantCoefficient;
Cvm 0.5;
}
water_dispersedIn_oil
{
type constantCoefficient;
Cvm 0.5;
}
}
heatTransfer
{
oil_dispersedIn_water
{
type RanzMarshall;
residualAlpha 1e-4;
}
water_dispersedIn_oil
{
type RanzMarshall;
residualAlpha 1e-4;
}
}
phaseTransfer
{}
lift
{}
wallLubrication
{}
turbulentDispersion
{}
interfaceCompression
{}
// ************************************************************************* //

51
tutorials/modules/CHT/multiphaseCoolingCylinder2D/constant/fluid/physicalProperties.oil Normal file
View File

@ -0,0 +1,51 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
location "constant";
object physicalProperties.oil;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture pureMixture;
transport const;
thermo eConst;
equationOfState rhoConst;
specie specie;
energy sensibleInternalEnergy;
}
mixture
{
specie
{
molWeight 160;
}
equationOfState
{
rho 800;
}
thermodynamics
{
Cv 2000;
Hf 0;
}
transport
{
mu 2e-3;
Pr 100;
}
}
// ************************************************************************* //

51
tutorials/modules/CHT/multiphaseCoolingCylinder2D/constant/fluid/physicalProperties.water Normal file
View File

@ -0,0 +1,51 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
location "constant";
object physicalProperties.water;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType
{
type heRhoThermo;
mixture pureMixture;
transport const;
thermo eConst;
equationOfState rPolynomial;
specie specie;
energy sensibleInternalEnergy;
}
mixture
{
specie
{
molWeight 18;
}
equationOfState
{
C (0.001278 -2.1055e-06 3.9689e-09 4.3772e-13 -2.0225e-16);
}
thermodynamics
{
Cv 4195;
Hf 0;
}
transport
{
mu 3.645e-4;
Pr 2.289;
}
}
// ************************************************************************* //

37
tutorials/modules/CHT/multiphaseCoolingCylinder2D/constant/solid/physicalProperties Normal file
View File

@ -0,0 +1,37 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object physicalProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
thermoType constSolidThermo;
rho
{
type uniform;
value 8940;
}
Cv
{
type uniform;
value 385;
}
kappa
{
type uniform;
value 380;
}
// ************************************************************************* //

158
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/blockMeshDict Normal file
View File

@ -0,0 +1,158 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 1;
cylinderRadius 0.005; // Radius of the cylinder
cylinderCore 0.002; // Radius of the core block inside the cylinder
halfWidth 0.04; // Half the channel width
halfThickness 0.0025; // Half the domain thickness
xDownstream 0.1; // X-coordinate of the downstream outlet
cylinderRadialCells 12; // Cells across the radius of the non-core part of the cylinder
cylinderCoreCells 15; // Cells across the core block inside the cylinder
widthCells 30; // Cells across the domain width
downstreamCells 20; // Cells across the downstream region
radialGrading 20; // Expansion ratio outside the cylinder in a radial direction
geometry
{
cylinder
{
type searchableCylinder;
point1 (0 0 -100);
point2 (0 0 100);
radius $cylinderRadius;
}
}
vertices
(
project (#neg $cylinderCore #neg $cylinderCore #neg $halfThickness) (cylinder)
project ( $cylinderCore #neg $cylinderCore #neg $halfThickness) (cylinder)
project (#neg $cylinderCore #neg $cylinderCore $halfThickness) (cylinder)
project ( $cylinderCore #neg $cylinderCore $halfThickness) (cylinder)
project (#neg $cylinderCore $cylinderCore #neg $halfThickness) (cylinder)
project ( $cylinderCore $cylinderCore #neg $halfThickness) (cylinder)
project (#neg $cylinderCore $cylinderCore $halfThickness) (cylinder)
project ( $cylinderCore $cylinderCore $halfThickness) (cylinder)
(#neg $halfWidth #neg $halfWidth #neg $halfThickness)
( $halfWidth #neg $halfWidth #neg $halfThickness)
(#neg $halfWidth #neg $halfWidth $halfThickness)
( $halfWidth #neg $halfWidth $halfThickness)
(#neg $halfWidth $halfWidth #neg $halfThickness)
( $halfWidth $halfWidth #neg $halfThickness)
(#neg $halfWidth $halfWidth $halfThickness)
( $halfWidth $halfWidth $halfThickness)
($xDownstream #neg $halfWidth #neg $halfThickness)
($xDownstream #neg $halfWidth $halfThickness)
($xDownstream $halfWidth #neg $halfThickness)
($xDownstream $halfWidth $halfThickness)
(#neg $cylinderCore #neg $cylinderCore #neg $halfThickness)
( $cylinderCore #neg $cylinderCore #neg $halfThickness)
( $cylinderCore #neg $cylinderCore $halfThickness)
(#neg $cylinderCore #neg $cylinderCore $halfThickness)
(#neg $cylinderCore $cylinderCore #neg $halfThickness)
( $cylinderCore $cylinderCore #neg $halfThickness)
( $cylinderCore $cylinderCore $halfThickness)
(#neg $cylinderCore $cylinderCore $halfThickness)
);
graded simpleGrading (1 $radialGrading 1);
uniform simpleGrading (1 1 1);
blocks
(
hex (4 6 14 12 0 2 10 8) fluid (1 $widthCells $cylinderCoreCells) $graded
hex (7 5 13 15 3 1 9 11) fluid (1 $widthCells $cylinderCoreCells) $graded
hex (2 3 11 10 0 1 9 8) fluid ($cylinderCoreCells $widthCells 1) $graded
hex (7 6 14 15 5 4 12 13) fluid ($cylinderCoreCells $widthCells 1) $graded
hex (13 18 19 15 9 16 17 11) fluid ($downstreamCells 1 $cylinderCoreCells) $uniform
hex (24 25 26 27 20 21 22 23) solid ($cylinderCoreCells 1 $cylinderCoreCells) $uniform
hex (0 2 23 20 4 6 27 24) solid (1 $cylinderRadialCells $cylinderCoreCells) $uniform
hex (21 22 3 1 25 26 7 5) solid (1 $cylinderRadialCells $cylinderCoreCells) $uniform
hex (0 2 3 1 20 23 22 21) solid (1 $cylinderCoreCells $cylinderRadialCells) $uniform
hex (4 5 7 6 24 25 26 27) solid ($cylinderCoreCells 1 $cylinderRadialCells) $uniform
);
edges
(
project 0 2 (cylinder)
project 2 3 (cylinder)
project 3 1 (cylinder)
project 1 0 (cylinder)
project 4 6 (cylinder)
project 6 7 (cylinder)
project 7 5 (cylinder)
project 5 4 (cylinder)
project 0 4 (cylinder)
project 2 6 (cylinder)
project 3 7 (cylinder)
project 1 5 (cylinder)
);
faces
(
);
defaultPatch
{
name frontAndBack;
type empty;
}
boundary
(
inlet
{
type patch;
faces
(
(8 10 14 12)
);
}
outlet
{
type patch;
faces
(
(16 17 19 18)
);
}
topAndBottom
{
type patch;
faces
(
(8 9 11 10)
(12 13 15 14)
(9 16 17 11)
(13 18 19 15)
);
}
);
// ************************************************************************* //

80
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/controlDict Normal file
View File

@ -0,0 +1,80 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application foamMultiRun;
regionSolvers
{
fluid multiphaseEuler;
solid solid;
}
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 5;
deltaT 1e-4;
writeControl adjustableRunTime;
writeInterval 0.1;
purgeWrite 0;
writeFormat ascii;
writePrecision 8;
writeCompression off;
timeFormat general;
timePrecision 6;
runTimeModifiable true;
adjustTimeStep yes;
maxCo 0.25;
maxDi 200;
maxDeltaT 1;
functions
{
#includeFunc patchAverage
(
funcName=cylinderToil,
region=fluid,
patch=fluid_to_solid,
field=T.oil
)
#includeFunc patchAverage
(
funcName=cylinderTwater,
region=fluid,
patch=fluid_to_solid,
field=T.water
)
}
// ************************************************************************* //

23
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/fluid/fvConstraints Normal file
View File

@ -0,0 +1,23 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object fvConstraints;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
limitp
{
type limitPressure;
min 1e4;
}
// ************************************************************************* //

65
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/fluid/fvSchemes Normal file
View File

@ -0,0 +1,65 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
location "system";
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
}
divSchemes
{
default none;
div(phi,alpha.oil) Gauss vanLeer;
div(phi,alpha.water) Gauss vanLeer;
div(phir,alpha.water,alpha.oil) Gauss vanLeer;
div(phir,alpha.oil,alpha.water) Gauss vanLeer;
div(alphaRhoPhi,U) Gauss limitedLinearV 1;
div(phi,U) Gauss limitedLinearV 1;
"div\(alphaRhoPhi,(h|e)\)" Gauss limitedLinear 1;
div(alphaRhoPhi,K) Gauss limitedLinear 1;
div(alphaRhoPhi,(p|rho)) Gauss limitedLinear 1;
"div\(alphaRhoPhi,(k|epsilon)\)" Gauss limitedLinear 1;
"div\(phim,(k|epsilon)m\)" Gauss limitedLinear 1;
div((((alpha*rho)*nuEff)*dev2(T(grad(U))))) Gauss linear;
}
laplacianSchemes
{
default Gauss linear corrected;
}
interpolationSchemes
{
default linear;
}
snGradSchemes
{
default corrected;
}
// ************************************************************************* //

83
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/fluid/fvSolution Normal file
View File

@ -0,0 +1,83 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
location "system";
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
"alpha.*"
{
nAlphaCorr 1;
nAlphaSubCycles 2;
}
p_rgh
{
solver GAMG;
smoother DIC;
tolerance 1e-7;
relTol 0.01;
}
p_rghFinal
{
$p_rgh;
relTol 0;
}
"U.*"
{
solver PBiCGStab;
preconditioner DILU;
tolerance 1e-7;
relTol 0;
}
"e.*"
{
solver PBiCGStab;
preconditioner DILU;
tolerance 1e-7;
relTol 0;
}
"(k|epsilon).*"
{
solver PBiCGStab;
preconditioner DILU;
tolerance 1e-7;
relTol 0;
}
}
PIMPLE
{
nCorrectors 1;
nNonOrthogonalCorrectors 1;
}
relaxationFactors
{
equations
{
".*" 1;
}
}
// ************************************************************************* //

45
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/fvSchemes Normal file
View File

@ -0,0 +1,45 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
}
gradSchemes
{
}
divSchemes
{
}
laplacianSchemes
{
}
interpolationSchemes
{
}
snGradSchemes
{
}
fluxRequired
{
}
// ************************************************************************* //

21
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/fvSolution Normal file
View File

@ -0,0 +1,21 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
"(PIMPLE|PISO)"
{
nOuterCorrectors 3;
}
// ************************************************************************* //

46
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/solid/fvSchemes Normal file
View File

@ -0,0 +1,46 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
}
divSchemes
{
default none;
}
laplacianSchemes
{
default Gauss linear uncorrected;
}
interpolationSchemes
{
default linear;
}
snGradSchemes
{
default uncorrected;
}
// ************************************************************************* //

46
tutorials/modules/CHT/multiphaseCoolingCylinder2D/system/solid/fvSolution Normal file
View File

@ -0,0 +1,46 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
e
{
solver PCG;
preconditioner DIC;
tolerance 1e-06;
relTol 0.1;
}
eFinal
{
$e;
relTol 0;
}
}
PIMPLE
{
nNonOrthogonalCorrectors 0;
}
relaxationFactors
{
equations
{
".*" 1;
}
}
// ************************************************************************* //