From c681206a947ad8cbb3f41ef511414d9e74333392 Mon Sep 17 00:00:00 2001 From: Vuko Vukcevic Date: Tue, 5 Jun 2018 09:17:07 +0200 Subject: [PATCH 1/4] fixedHeatFluxTemperature boundary condition The boundary condition uses a specified heat flux and kappe effective to calculate the temperature gradient. It is a part of LES library in order to allow both RAS and LES models to use the BC. --- .../incompressible/LES/Make/files | 1 + ...xedHeatFluxTemperatureFvPatchScalarField.C | 234 ++++++++++++++++++ ...xedHeatFluxTemperatureFvPatchScalarField.H | 167 +++++++++++++ 3 files changed, 402 insertions(+) create mode 100644 src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C create mode 100644 src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H diff --git a/src/turbulenceModels/incompressible/LES/Make/files b/src/turbulenceModels/incompressible/LES/Make/files index ff17b596e..817f0520c 100644 --- a/src/turbulenceModels/incompressible/LES/Make/files +++ b/src/turbulenceModels/incompressible/LES/Make/files @@ -33,6 +33,7 @@ wallFunctions=derivedFvPatchFields/wallFunctions derivedFvPatchFields/decayingTurbulence/decayingVorton.C derivedFvPatchFields/decayingTurbulence/decayingTurbulenceFvPatchVectorField.C +derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C nuSgsWallFunctions=$(wallFunctions)/nuSgsWallFunctions $(nuSgsWallFunctions)/nuSgsWallFunction/nuSgsWallFunctionFvPatchScalarField.C diff --git a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C new file mode 100644 index 000000000..80d820449 --- /dev/null +++ b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C @@ -0,0 +1,234 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | foam-extend: Open Source CFD + \\ / O peration | Version: 4.0 + \\ / A nd | Web: http://www.foam-extend.org + \\/ M anipulation | For copyright notice see file Copyright +------------------------------------------------------------------------------- +License + This file is part of foam-extend. + + foam-extend 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. + + foam-extend 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 foam-extend. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "fixedHeatFluxTemperatureFvPatchScalarField.H" +#include "incompressible/RAS/RASModel/RASModel.H" +#include "incompressible/LES/LESModel/LESModel.H" +#include "addToRunTimeSelectionTable.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +fixedHeatFluxTemperatureFvPatchScalarField:: +fixedHeatFluxTemperatureFvPatchScalarField +( + const fvPatch& p, + const DimensionedField& iF +) +: + fixedGradientFvPatchScalarField(p, iF), + heatFlux_(p.size(), 0.0), + Pr_(0.0), + Prt_(0.0) +{ + this->gradient() = 0.0; +} + + +fixedHeatFluxTemperatureFvPatchScalarField:: +fixedHeatFluxTemperatureFvPatchScalarField +( + const fvPatch& p, + const DimensionedField& iF, + const dictionary& dict +) +: + fixedGradientFvPatchScalarField(p, iF), + heatFlux_("heatFlux", dict, p.size()), + Pr_(0.0), // Initialized in constructor body + Prt_(0.0) // Initialized in constructor body +{ + // Set dummy gradient + this->gradient() = 0.0; + + // Read the value entry from the dictionary + if (dict.found("value")) + { + fvPatchScalarField::operator= + ( + scalarField("value", dict, p.size()) + ); + } + else + { + FatalIOErrorIn + ( + "fixedHeatFluxTemperatureFvPatchScalarField::" + "fixedHeatFluxTemperatureFvPatchScalarField" + "(" + "const fvPatch& p," + "const DimensionedField& iF," + "const dictionary& dict," + "const bool valueRequired" + ")", + dict + ) << "Essential entry 'value' missing" + << exit(FatalIOError); + } + + // Get mesh + const fvMesh& mesh = this->dimensionedInternalField().mesh(); + + // Create transportProperties dictionary + IOdictionary transportProperties + ( + IOobject + ( + "transportProperties", + mesh.time().constant(), + mesh, + IOobject::MUST_READ, + IOobject::NO_WRITE, + false // do not register in the database + ) + ); + + // Read in Prandtl numbers + Pr_ = dimensionedScalar(transportProperties.lookup("Pr")).value(); + Prt_ = dimensionedScalar(transportProperties.lookup("Prt")).value(); +} + + +fixedHeatFluxTemperatureFvPatchScalarField:: +fixedHeatFluxTemperatureFvPatchScalarField +( + const fixedHeatFluxTemperatureFvPatchScalarField& ptf, + const fvPatch& p, + const DimensionedField& iF, + const fvPatchFieldMapper& mapper +) +: + fixedGradientFvPatchScalarField(ptf, p, iF, mapper), + heatFlux_(ptf.heatFlux_), + Pr_(ptf.Pr_), + Prt_(ptf.Prt_) +{} + + +fixedHeatFluxTemperatureFvPatchScalarField:: +fixedHeatFluxTemperatureFvPatchScalarField +( + const fixedHeatFluxTemperatureFvPatchScalarField& ptf +) +: + fixedGradientFvPatchScalarField(ptf), + heatFlux_(ptf.heatFlux_), + Pr_(ptf.Pr_), + Prt_(ptf.Prt_) +{} + + +fixedHeatFluxTemperatureFvPatchScalarField:: +fixedHeatFluxTemperatureFvPatchScalarField +( + const fixedHeatFluxTemperatureFvPatchScalarField& ptf, + const DimensionedField& iF +) +: + fixedGradientFvPatchScalarField(ptf, iF), + heatFlux_(ptf.heatFlux_), + Pr_(ptf.Pr_), + Prt_(ptf.Prt_) +{} + + +// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // + +void fixedHeatFluxTemperatureFvPatchScalarField::updateCoeffs() +{ + if (this->updated()) + { + return; + } + + // Calculate the gradient depending on the turbulence model + const fvMesh& mesh = this->dimensionedInternalField().mesh(); + + // Get this patch index + const label patchID = this->patch().index(); + + if (mesh.foundObject("RASProperties")) + { + const incompressible::RASModel& ras = + mesh.lookupObject("RASProperties"); + + // Calculate effective kappa at the patch + const scalarField kappaEffp = + ras.nu().boundaryField()[patchID]/Pr_ + + ras.nut()().boundaryField()[patchID]/Prt_; + + this->gradient() = heatFlux_/kappaEffp; + } + else if (mesh.foundObject("LESProperties")) + { + const incompressible::LESModel& les = + mesh.lookupObject("LESProperties"); + + // Calculate effective kappa at the patch + const scalarField kappaEffp = + les.nu().boundaryField()[patchID]/Pr_ + + les.nut()().boundaryField()[patchID]/Prt_; + + this->gradient() = heatFlux_/kappaEffp; + } + else + { + FatalErrorIn + ( + "fixedHeatFluxTemperatureFvPatchScalarField::updateCoeffs()" + ) << " No valid model for effective kappa calculations." + << abort(FatalError); + } + + fixedGradientFvPatchScalarField::updateCoeffs(); +} + + +void fixedHeatFluxTemperatureFvPatchScalarField::write(Ostream& os) const +{ + fixedGradientFvPatchScalarField::write(os); + heatFlux_.writeEntry("heatFlux", os); + this->writeEntry("value", os); +} + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +makePatchTypeField +( + fvPatchScalarField, + fixedHeatFluxTemperatureFvPatchScalarField +); + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace Foam + +// ************************************************************************* // diff --git a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H new file mode 100644 index 000000000..6cefdf919 --- /dev/null +++ b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H @@ -0,0 +1,167 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | foam-extend: Open Source CFD + \\ / O peration | Version: 4.0 + \\ / A nd | Web: http://www.foam-extend.org + \\/ M anipulation | For copyright notice see file Copyright +------------------------------------------------------------------------------- +License + This file is part of foam-extend. + + foam-extend 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. + + foam-extend 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 foam-extend. If not, see . + +Class + Foam::fixedHeatFluxTemperatureFvPatchScalarField + +Description + + Fixed temperature flux boundary condition. Assumes incompressible turbulent + flow. The normal temperature gradient is calculated as: + + snGrad(T) = q/kappaEff + + where: + - q is the prescribed heat flux [W/m^2], + - kappaEff is the effective diffusivity field: nu/Pr + nu_t/Pr_t, + - Pr and Prt are laminar and turbulent Prandtl number read from + transportProperties dictionary + + Designed to be used alongside solvers with Boussinesq buoyancy + approximation (e.g. buoyantBoussinesqSimpleFoam). + +Author + Vuko Vukcevic, Wikki Ltd. All rights reserved + +SourceFiles + fixedHeatFluxTemperatureFvPatchScalarField.C + +\*---------------------------------------------------------------------------*/ + +#ifndef fixedHeatFluxTemperatureFvPatchScalarField_H +#define fixedHeatFluxTemperatureFvPatchScalarField_H + +#include "fixedGradientFvPatchFields.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ + +/*---------------------------------------------------------------------------*\ + Class fixedHeatFluxTemperatureFvPatchScalarField Declaration +\*---------------------------------------------------------------------------*/ + +class fixedHeatFluxTemperatureFvPatchScalarField +: + public fixedGradientFvPatchScalarField +{ + // Private data + + //- Fixed heat flux + scalarField heatFlux_; + + //- Laminar Prandtl number + scalar Pr_; + + //- Turbulent Prandtl number + scalar Prt_; + + +public: + + //- Runtime type information + TypeName("fixedHeatFluxTemperature"); + + + // Constructors + + //- Construct from patch and internal field + fixedHeatFluxTemperatureFvPatchScalarField + ( + const fvPatch&, + const DimensionedField& + ); + + //- Construct from patch, internal field and dictionary + fixedHeatFluxTemperatureFvPatchScalarField + ( + const fvPatch&, + const DimensionedField&, + const dictionary& + ); + + //- Construct by mapping given + // fixedHeatFluxTemperatureFvPatchScalarField onto a new patch + fixedHeatFluxTemperatureFvPatchScalarField + ( + const fixedHeatFluxTemperatureFvPatchScalarField&, + const fvPatch&, + const DimensionedField&, + const fvPatchFieldMapper& + ); + + //- Construct as copy + fixedHeatFluxTemperatureFvPatchScalarField + ( + const fixedHeatFluxTemperatureFvPatchScalarField& + ); + + //- Construct and return a clone + virtual tmp clone() const + { + return tmp + ( + new fixedHeatFluxTemperatureFvPatchScalarField(*this) + ); + } + + //- Construct as copy setting internal field reference + fixedHeatFluxTemperatureFvPatchScalarField + ( + const fixedHeatFluxTemperatureFvPatchScalarField&, + const DimensionedField& + ); + + //- Construct and return a clone setting internal field reference + virtual tmp clone + ( + const DimensionedField& iF + ) const + { + return tmp + ( + new fixedHeatFluxTemperatureFvPatchScalarField(*this, iF) + ); + } + + + // Member functions + + //- Update the coefficients associated with the patch field + virtual void updateCoeffs(); + + //- Write + virtual void write(Ostream&) const; +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* // From 27e5ca1f6b9891a0e1c66d6f3d4462995df52883 Mon Sep 17 00:00:00 2001 From: Vuko Vukcevic Date: Mon, 11 Jun 2018 13:16:17 +0200 Subject: [PATCH 2/4] Bugfix in fixedHeatFluxTemperature BC Forgot that I need to divide the heat flux with reference density and specific heat capacity to get the gradient... --- ...xedHeatFluxTemperatureFvPatchScalarField.C | 124 ++++++++++++++++-- ...xedHeatFluxTemperatureFvPatchScalarField.H | 13 +- 2 files changed, 122 insertions(+), 15 deletions(-) diff --git a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C index 80d820449..565fa37e6 100644 --- a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C +++ b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C @@ -45,7 +45,9 @@ fixedHeatFluxTemperatureFvPatchScalarField fixedGradientFvPatchScalarField(p, iF), heatFlux_(p.size(), 0.0), Pr_(0.0), - Prt_(0.0) + Prt_(0.0), + rhoRef_(0.0), + c_(0.0) { this->gradient() = 0.0; } @@ -61,8 +63,10 @@ fixedHeatFluxTemperatureFvPatchScalarField : fixedGradientFvPatchScalarField(p, iF), heatFlux_("heatFlux", dict, p.size()), - Pr_(0.0), // Initialized in constructor body - Prt_(0.0) // Initialized in constructor body + Pr_(0.0), // Initialized in constructor body + Prt_(0.0), // Initialized in constructor body + rhoRef_(0.0), // Initialized in constructor body + c_(0.0) // Initialized in constructor body { // Set dummy gradient this->gradient() = 0.0; @@ -109,9 +113,101 @@ fixedHeatFluxTemperatureFvPatchScalarField ) ); - // Read in Prandtl numbers - Pr_ = dimensionedScalar(transportProperties.lookup("Pr")).value(); - Prt_ = dimensionedScalar(transportProperties.lookup("Prt")).value(); + // Read in all the necessary data as dimensioned scalars + const dimensionedScalar PrDim = + dimensionedScalar(transportProperties.lookup("Pr")); + + const dimensionedScalar PrtDim = + dimensionedScalar(transportProperties.lookup("Prt")); + + const dimensionedScalar rhoRefDim = + dimensionedScalar(transportProperties.lookup("rhoRef")); + + const dimensionedScalar cDim = + dimensionedScalar(transportProperties.lookup("c")); + + // Perform sanity checks for dimensions + if (PrDim.dimensions() != dimless) + { + FatalIOErrorIn + ( + "fixedHeatFluxTemperatureFvPatchScalarField::" + "fixedHeatFluxTemperatureFvPatchScalarField" + "\n(" + "\n const fvPatch& p," + "\n const DimensionedField& iF," + "\n const dictionary& dict" + "\n)", + dict + ) << "Wrong dimensions for Prandtl number (Pr) detected: " + << PrDim.dimensions() + << nl + << "They should be: " << dimless + << abort(FatalIOError); + } + + if (PrtDim.dimensions() != dimless) + { + FatalIOErrorIn + ( + "fixedHeatFluxTemperatureFvPatchScalarField::" + "fixedHeatFluxTemperatureFvPatchScalarField" + "\n(" + "\n const fvPatch& p," + "\n const DimensionedField& iF," + "\n const dictionary& dict" + "\n)", + dict + ) << "Wrong dimensions for turbulent Prandtl number (Prt) detected: " + << PrtDim.dimensions() + << nl + << "They should be: " << dimless + << abort(FatalIOError); + } + + if (rhoRefDim.dimensions() != dimDensity) + { + FatalIOErrorIn + ( + "fixedHeatFluxTemperatureFvPatchScalarField::" + "fixedHeatFluxTemperatureFvPatchScalarField" + "\n(" + "\n const fvPatch& p," + "\n const DimensionedField& iF," + "\n const dictionary& dict" + "\n)", + dict + ) << "Wrong dimensions for reference density (rhoRef) detected: " + << rhoRefDim.dimensions() + << nl + << "They should be: " << dimDensity + << abort(FatalIOError); + } + + if (cDim.dimensions() != dimSpecificHeatCapacity) + { + FatalIOErrorIn + ( + "fixedHeatFluxTemperatureFvPatchScalarField::" + "fixedHeatFluxTemperatureFvPatchScalarField" + "\n(" + "\n const fvPatch& p," + "\n const DimensionedField& iF," + "\n const dictionary& dict" + "\n)", + dict + ) << "Wrong dimensions for specific heat capacity (c) detected: " + << cDim.dimensions() + << nl + << "They should be: " << dimSpecificHeatCapacity + << abort(FatalIOError); + } + + // Store values in data members + Pr_ = PrDim.value(); + Prt_ = PrtDim.value(); + rhoRef_ = rhoRefDim.value(); + c_ = cDim.value(); } @@ -127,7 +223,9 @@ fixedHeatFluxTemperatureFvPatchScalarField fixedGradientFvPatchScalarField(ptf, p, iF, mapper), heatFlux_(ptf.heatFlux_), Pr_(ptf.Pr_), - Prt_(ptf.Prt_) + Prt_(ptf.Prt_), + rhoRef_(ptf.rhoRef_), + c_(ptf.c_) {} @@ -140,7 +238,9 @@ fixedHeatFluxTemperatureFvPatchScalarField fixedGradientFvPatchScalarField(ptf), heatFlux_(ptf.heatFlux_), Pr_(ptf.Pr_), - Prt_(ptf.Prt_) + Prt_(ptf.Prt_), + rhoRef_(ptf.rhoRef_), + c_(ptf.c_) {} @@ -154,7 +254,9 @@ fixedHeatFluxTemperatureFvPatchScalarField fixedGradientFvPatchScalarField(ptf, iF), heatFlux_(ptf.heatFlux_), Pr_(ptf.Pr_), - Prt_(ptf.Prt_) + Prt_(ptf.Prt_), + rhoRef_(ptf.rhoRef_), + c_(ptf.c_) {} @@ -183,7 +285,7 @@ void fixedHeatFluxTemperatureFvPatchScalarField::updateCoeffs() ras.nu().boundaryField()[patchID]/Pr_ + ras.nut()().boundaryField()[patchID]/Prt_; - this->gradient() = heatFlux_/kappaEffp; + this->gradient() = heatFlux_/(kappaEffp*rhoRef_*c_); } else if (mesh.foundObject("LESProperties")) { @@ -195,7 +297,7 @@ void fixedHeatFluxTemperatureFvPatchScalarField::updateCoeffs() les.nu().boundaryField()[patchID]/Pr_ + les.nut()().boundaryField()[patchID]/Prt_; - this->gradient() = heatFlux_/kappaEffp; + this->gradient() = heatFlux_/(kappaEffp*rhoRef_*c_); } else { diff --git a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H index 6cefdf919..fb3b0c70e 100644 --- a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H +++ b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.H @@ -29,16 +29,15 @@ Description Fixed temperature flux boundary condition. Assumes incompressible turbulent flow. The normal temperature gradient is calculated as: - snGrad(T) = q/kappaEff + snGrad(T) = q/(kappaEff*rhoRef*c) where: - q is the prescribed heat flux [W/m^2], - kappaEff is the effective diffusivity field: nu/Pr + nu_t/Pr_t, - Pr and Prt are laminar and turbulent Prandtl number read from transportProperties dictionary - - Designed to be used alongside solvers with Boussinesq buoyancy - approximation (e.g. buoyantBoussinesqSimpleFoam). + - rhoRef is the reference density + - c is the specific heat capacity Author Vuko Vukcevic, Wikki Ltd. All rights reserved @@ -77,6 +76,12 @@ class fixedHeatFluxTemperatureFvPatchScalarField //- Turbulent Prandtl number scalar Prt_; + //- Reference density + scalar rhoRef_; + + //- Specific heat capacity of the fluid + scalar c_; + public: From 3d6293352a87a2cc6f5d847adf2f962c1ac43d12 Mon Sep 17 00:00:00 2001 From: Vuko Vukcevic Date: Mon, 11 Jun 2018 14:23:48 +0200 Subject: [PATCH 3/4] Bugfix in fixedHeatFluxTemperature BC 1. Reading in gradient from dictionary if present, 2. No need to distinguish between RAS and LES models: use turbulenceModel instead. --- ...xedHeatFluxTemperatureFvPatchScalarField.C | 37 ++++++++----------- 1 file changed, 15 insertions(+), 22 deletions(-) diff --git a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C index 565fa37e6..afaa0a724 100644 --- a/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C +++ b/src/turbulenceModels/incompressible/LES/derivedFvPatchFields/fixedHeatFluxTemperature/fixedHeatFluxTemperatureFvPatchScalarField.C @@ -48,9 +48,7 @@ fixedHeatFluxTemperatureFvPatchScalarField Prt_(0.0), rhoRef_(0.0), c_(0.0) -{ - this->gradient() = 0.0; -} +{} fixedHeatFluxTemperatureFvPatchScalarField:: @@ -68,8 +66,11 @@ fixedHeatFluxTemperatureFvPatchScalarField rhoRef_(0.0), // Initialized in constructor body c_(0.0) // Initialized in constructor body { - // Set dummy gradient - this->gradient() = 0.0; + // Read the gradient entry from the dictionary + if (dict.found("gradient")) + { + this->gradient() = scalarField("gradient", dict, p.size()); + } // Read the value entry from the dictionary if (dict.found("value")) @@ -275,28 +276,20 @@ void fixedHeatFluxTemperatureFvPatchScalarField::updateCoeffs() // Get this patch index const label patchID = this->patch().index(); - if (mesh.foundObject("RASProperties")) + if (mesh.foundObject("turbulenceModel")) { - const incompressible::RASModel& ras = - mesh.lookupObject("RASProperties"); + const incompressible::turbulenceModel& turb = + mesh.lookupObject + < + incompressible::turbulenceModel + >("turbulenceModel"); // Calculate effective kappa at the patch const scalarField kappaEffp = - ras.nu().boundaryField()[patchID]/Pr_ - + ras.nut()().boundaryField()[patchID]/Prt_; - - this->gradient() = heatFlux_/(kappaEffp*rhoRef_*c_); - } - else if (mesh.foundObject("LESProperties")) - { - const incompressible::LESModel& les = - mesh.lookupObject("LESProperties"); - - // Calculate effective kappa at the patch - const scalarField kappaEffp = - les.nu().boundaryField()[patchID]/Pr_ - + les.nut()().boundaryField()[patchID]/Prt_; + turb.nu().boundaryField()[patchID]/Pr_ + + turb.nut()().boundaryField()[patchID]/Prt_; + // Calculate gradient at the boundary this->gradient() = heatFlux_/(kappaEffp*rhoRef_*c_); } else From b4a7a0e33fa80d961052a302ff7055475546ae70 Mon Sep 17 00:00:00 2001 From: Vuko Vukcevic Date: Mon, 11 Jun 2018 14:24:54 +0200 Subject: [PATCH 4/4] buoyantWallHeatFlux utility Variant of wallHeatFlux utility for incompressible flow with Boussinesq's buoyancy assumption (e.g. buoyantBoussinesqSimpleFoam). Reports total wall heat flux on each wall and also writes buoyantWallHeatFlux as volScalarField for easy visualisation. --- .../wall/buoyantWallHeatFlux/CMakeLists.txt | 46 +++++++ .../wall/buoyantWallHeatFlux/Make/files | 3 + .../wall/buoyantWallHeatFlux/Make/options | 20 +++ .../buoyantWallHeatFlux/buoyantWallHeatFlux.C | 116 ++++++++++++++++++ .../wall/buoyantWallHeatFlux/createFields.H | 44 +++++++ .../readTransportProperties.H | 13 ++ 6 files changed, 242 insertions(+) create mode 100644 applications/utilities/postProcessing/wall/buoyantWallHeatFlux/CMakeLists.txt create mode 100644 applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/files create mode 100644 applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/options create mode 100644 applications/utilities/postProcessing/wall/buoyantWallHeatFlux/buoyantWallHeatFlux.C create mode 100644 applications/utilities/postProcessing/wall/buoyantWallHeatFlux/createFields.H create mode 100644 applications/utilities/postProcessing/wall/buoyantWallHeatFlux/readTransportProperties.H diff --git a/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/CMakeLists.txt b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/CMakeLists.txt new file mode 100644 index 000000000..571a56d21 --- /dev/null +++ b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/CMakeLists.txt @@ -0,0 +1,46 @@ +# -------------------------------------------------------------------------- +# ======== | +# \ / F ield | foam-extend: Open Source CFD +# \ / O peration | Version: 4.1 +# \ / A nd | Web: http://www.foam-extend.org +# \/ M anipulation | For copyright notice see file Copyright +# -------------------------------------------------------------------------- +# License +# This file is part of foam-extend. +# +# foam-extend 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. +# +# foam-extend 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 foam-extend. If not, see . +# +# Description +# CMakeLists.txt file for libraries and applications +# +# Author +# Henrik Rusche, Wikki GmbH, 2017. All rights reserved +# +# +# -------------------------------------------------------------------------- + +list(APPEND SOURCES + buoyantWallHeatFlux.C +) + +# Set minimal environment for external compilation +if(NOT FOAM_FOUND) + cmake_minimum_required(VERSION 2.8) + find_package(FOAM REQUIRED) +endif() + +add_foam_executable(buoyantWallHeatFlux + DEPENDS incompressibleRASModels incompressibleTransportModels incompressibleLESModels + SOURCES ${SOURCES} +) diff --git a/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/files b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/files new file mode 100644 index 000000000..12d7cd037 --- /dev/null +++ b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/files @@ -0,0 +1,3 @@ +buoyantWallHeatFlux.C + +EXE = $(FOAM_APPBIN)/buoyantWallHeatFlux diff --git a/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/options b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/options new file mode 100644 index 000000000..a8459f127 --- /dev/null +++ b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/Make/options @@ -0,0 +1,20 @@ +EXE_INC = \ + -I$(LIB_SRC)/finiteVolume/lnInclude \ + -I$(LIB_SRC)/turbulenceModels \ + -I$(LIB_SRC)/turbulenceModels/LES/LESdeltas/lnInclude \ + -I$(LIB_SRC)/turbulenceModels/LES/LESfilters/lnInclude \ + -I$(LIB_SRC)/turbulenceModels/incompressible/RAS/lnInclude \ + -I$(LIB_SRC)/turbulenceModels/incompressible/LES/lnInclude \ + -I$(LIB_SRC)/transportModels \ + -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel + +EXE_LIBS = \ + -lfiniteVolume \ + -lmeshTools \ + -lincompressibleTurbulenceModel \ + -lincompressibleRASModels \ + -lincompressibleLESModels \ + -lincompressibleTransportModels \ + -lLESdeltas \ + -lLESfilters \ + -llduSolvers diff --git a/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/buoyantWallHeatFlux.C b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/buoyantWallHeatFlux.C new file mode 100644 index 000000000..8be247ee0 --- /dev/null +++ b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/buoyantWallHeatFlux.C @@ -0,0 +1,116 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | foam-extend: Open Source CFD + \\ / O peration | Version: 4.1 + \\ / A nd | Web: http://www.foam-extend.org + \\/ M anipulation | For copyright notice see file Copyright +------------------------------------------------------------------------------- +License + This file is part of foam-extend. + + foam-extend 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. + + foam-extend 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 foam-extend. If not, see . + +Application + buoyantWallHeatFlux + +Description + Calculates and writes the heat flux in incompressible flow with Boussinesq's + buoyancy assumption (e.g. buoyantBoussineqSimpleFoam) for all patches as the + boundary field of a volScalarField and also prints the integrated flux for + all wall patches. + +\*---------------------------------------------------------------------------*/ + +#include "fvCFD.H" +#include "RASModel.H" +#include "LESModel.H" +#include "singlePhaseTransportModel.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +int main(int argc, char *argv[]) +{ + timeSelector::addOptions(); + #include "setRootCase.H" + #include "createTime.H" + instantList timeDirs = timeSelector::select0(runTime, args); + #include "createMesh.H" + + forAll(timeDirs, timeI) + { + runTime.setTime(timeDirs[timeI], timeI); + Info<< "Time = " << runTime.timeName() << endl; + mesh.readUpdate(); + + #include "createFields.H" + + // Calculate effective kappa + const volScalarField kappaEff + ( + "kappaEff", + turbulence->nu()/Pr + turbulence->nut()/Prt + ); + + // Calculate the heat flux + const surfaceScalarField heatFlux = + rhoRef*c*fvc::interpolate(kappaEff)*fvc::snGrad(T); + + // Get the heat flux at the patch + const surfaceScalarField::GeometricBoundaryField& patchHeatFlux = + heatFlux.boundaryField(); + + Info<< "\nWall heat fluxes [W]" << endl; + forAll(patchHeatFlux, patchi) + { + if (mesh.boundary()[patchi].isWall()) + { + Info<< mesh.boundary()[patchi].name() + << " " + << gSum + ( + mesh.magSf().boundaryField()[patchi] + *patchHeatFlux[patchi] + ) + << endl; + } + } + Info<< endl; + + // Create the volScalarField which will have heat fluxes at the boundary + volScalarField buoyantWallHeatFlux + ( + IOobject + ( + "buoyantWallHeatFlux", + runTime.timeName(), + mesh + ), + mesh, + dimensionedScalar("buoyantWallHeatFlux", heatFlux.dimensions(), 0.0) + ); + + forAll(buoyantWallHeatFlux.boundaryField(), patchi) + { + buoyantWallHeatFlux.boundaryField()[patchi] = patchHeatFlux[patchi]; + } + + buoyantWallHeatFlux.write(); + } + + Info<< "End" << endl; + + return 0; +} + +// ************************************************************************* // diff --git a/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/createFields.H b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/createFields.H new file mode 100644 index 000000000..aeb88fdf1 --- /dev/null +++ b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/createFields.H @@ -0,0 +1,44 @@ +// Read velocity field for turbulence +volVectorField U +( + IOobject + ( + "U", + runTime.timeName(), + mesh, + IOobject::MUST_READ, + IOobject::AUTO_WRITE + ), + mesh +); + +// Read temperature field +volScalarField T +( + IOobject + ( + "T", + runTime.timeName(), + mesh, + IOobject::MUST_READ, + IOobject::AUTO_WRITE + ), + mesh +); + +// Create the flux for turbulence +#include "createPhi.H" + +// Read transport properties and all necessary coefficients +#include "readTransportProperties.H" + +// Create generic turbulence model (RAS/LES) +autoPtr turbulence +( + incompressible::turbulenceModel::New + ( + U, + phi, + laminarTransport + ) +); diff --git a/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/readTransportProperties.H b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/readTransportProperties.H new file mode 100644 index 000000000..4b40046a8 --- /dev/null +++ b/applications/utilities/postProcessing/wall/buoyantWallHeatFlux/readTransportProperties.H @@ -0,0 +1,13 @@ + singlePhaseTransportModel laminarTransport(U, phi); + + // Laminar Prandtl number + const dimensionedScalar Pr(laminarTransport.lookup("Pr")); + + // Turbulent Prandtl number + const dimensionedScalar Prt(laminarTransport.lookup("Prt")); + + // Reference density + const dimensionedScalar rhoRef(laminarTransport.lookup("rhoRef")); + + // Specific heat capacity + const dimensionedScalar c(laminarTransport.lookup("c"));