OpenFOAM-dev / data /src /ThermophysicalTransportModels /coupledThermophysicalTransportModels /externalTemperature /externalTemperatureFvPatchScalarField.C
| /*---------------------------------------------------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Copyright (C) 2011-2026 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/>. | |
| \*---------------------------------------------------------------------------*/ | |
| // * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * // | |
| void Foam::externalTemperatureFvPatchScalarField::addEqOp | |
| ( | |
| tmp<scalarField>& tf, | |
| const scalar d | |
| ) const | |
| { | |
| if (!tf.valid()) | |
| { | |
| tf = new scalarField(size(), d); | |
| } | |
| else | |
| { | |
| tf.ref() += d; | |
| } | |
| } | |
| void Foam::externalTemperatureFvPatchScalarField::addEqOp | |
| ( | |
| tmp<scalarField>& tf, | |
| const tmp<scalarField>& tdf | |
| ) const | |
| { | |
| if (!tdf.valid()) | |
| { | |
| return; | |
| } | |
| if (!tf.valid()) | |
| { | |
| tf = tdf.ptr(); | |
| } | |
| else | |
| { | |
| tf.ref() += tdf; | |
| } | |
| } | |
| void Foam::externalTemperatureFvPatchScalarField::getKappa | |
| ( | |
| scalarField& kappa, | |
| tmp<scalarField>& sumKappaTcByDelta, | |
| tmp<scalarField>& sumKappaByDelta, | |
| tmp<scalarField>& T, | |
| tmp<scalarField>& sumq | |
| ) const | |
| { | |
| const thermophysicalTransportModel& ttm = | |
| patch().mesh() | |
| .lookupType<thermophysicalTransportModel>(); | |
| kappa = ttm.kappaEff(patch().index()); | |
| T = tmp<scalarField>(*this); | |
| addEqOp(sumq, ttm.qCorr(patch().index())); | |
| } | |
| // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // | |
| Foam::externalTemperatureFvPatchScalarField:: | |
| externalTemperatureFvPatchScalarField | |
| ( | |
| const fvPatch& p, | |
| const DimensionedField<scalar, fvMesh>& iF, | |
| const dictionary& dict | |
| ) | |
| : | |
| mixedFvPatchScalarField(p, iF, dict, false), | |
| haveQ_(dict.found("Q")), | |
| Q_ | |
| ( | |
| haveQ_ | |
| ? Function1<scalar>::New("Q", time().userUnits(), dimensions::power, dict) | |
| : autoPtr<Function1<scalar>>() | |
| ), | |
| haveq_(dict.found("q")), | |
| q_ | |
| ( | |
| haveq_ | |
| ? Function1<scalar>::New | |
| ( | |
| "q", | |
| time().userUnits(), | |
| dimensions::heatFluxDensity, | |
| dict | |
| ) | |
| : autoPtr<Function1<scalar>>() | |
| ), | |
| h_ | |
| ( | |
| dict.found("h") | |
| ? new FunctionalDimensionedField<scalar, fvPatch> | |
| ( | |
| iF.name(), | |
| "h", | |
| p, | |
| dimensions::heatFluxDensity/dimensions::temperature, | |
| dict | |
| ) | |
| : nullptr | |
| ), | |
| haveEmissivity_(dict.found("emissivity")), | |
| emissivity_ | |
| ( | |
| haveEmissivity_ | |
| ? dict.lookup<scalar>("emissivity", units::fraction) | |
| : NaN | |
| ), | |
| Ta_ | |
| ( | |
| h_.valid() || haveEmissivity_ | |
| ? Function1<scalar>::New | |
| ( | |
| "Ta", | |
| time().userUnits(), | |
| dimensions::temperature, | |
| dict | |
| ).ptr() | |
| : nullptr | |
| ), | |
| relax_(dict.lookupOrDefault<scalar>("relaxation", units::fraction, 1)), | |
| qrName_(dict.lookupOrDefault<word>("qr", word::null)), | |
| qrRelax_(dict.lookupOrDefault<scalar>("qrRelaxation", units::fraction, 1)), | |
| qrPrevious_ | |
| ( | |
| qrName_ != word::null | |
| ? dict.found("qrPrevious") | |
| ? scalarField | |
| ( | |
| "qrPrevious", | |
| dimensions::heatFluxDensity, | |
| dict, | |
| p.size() | |
| ) | |
| : scalarField(p.size(), 0) | |
| : scalarField() | |
| ) | |
| { | |
| fvPatchScalarField::operator= | |
| ( | |
| scalarField("value", iF.dimensions(), dict, p.size()) | |
| ); | |
| if (haveEmissivity_ && (emissivity_ < 0 || emissivity_ > 1)) | |
| { | |
| FatalIOErrorInFunction(dict) | |
| << "Emissivity must be in the range 0 to 1" | |
| << exit(FatalIOError); | |
| } | |
| if (dict.found("refValue")) | |
| { | |
| // Full restart | |
| refValue() = scalarField("refValue", iF.dimensions(), dict, p.size()); | |
| refGrad() = | |
| scalarField | |
| ( | |
| "refGradient", | |
| iF.dimensions()/dimensions::length, | |
| dict, | |
| p.size() | |
| ); | |
| valueFraction() = | |
| scalarField("valueFraction", units::fraction, dict, p.size()); | |
| } | |
| else | |
| { | |
| // Start from user entered data. Assume fixedValue. | |
| refValue() = *this; | |
| refGrad() = 0; | |
| valueFraction() = 1; | |
| } | |
| } | |
| Foam::externalTemperatureFvPatchScalarField:: | |
| externalTemperatureFvPatchScalarField | |
| ( | |
| const externalTemperatureFvPatchScalarField& ptf, | |
| const fvPatch& p, | |
| const DimensionedField<scalar, fvMesh>& iF, | |
| const fieldMapper& mapper | |
| ) | |
| : | |
| mixedFvPatchScalarField(ptf, p, iF, mapper), | |
| haveQ_(ptf.haveQ_), | |
| Q_(ptf.Q_, false), | |
| haveq_(ptf.haveq_), | |
| q_(ptf.q_, false), | |
| h_ | |
| ( | |
| ptf.h_.valid() | |
| ? new FunctionalDimensionedField<scalar, fvPatch> | |
| ( | |
| ptf.h_(), | |
| p, | |
| mapper | |
| ) | |
| : nullptr | |
| ), | |
| haveEmissivity_(ptf.haveEmissivity_), | |
| emissivity_(ptf.emissivity_), | |
| Ta_(ptf.Ta_, false), | |
| relax_(ptf.relax_), | |
| qrName_(ptf.qrName_), | |
| qrRelax_(ptf.qrRelax_), | |
| qrPrevious_ | |
| ( | |
| qrName_ != word::null | |
| ? mapper(ptf.qrPrevious_)() | |
| : scalarField() | |
| ) | |
| {} | |
| Foam::externalTemperatureFvPatchScalarField:: | |
| externalTemperatureFvPatchScalarField | |
| ( | |
| const externalTemperatureFvPatchScalarField& ptf, | |
| const DimensionedField<scalar, fvMesh>& iF | |
| ) | |
| : | |
| mixedFvPatchScalarField(ptf, iF), | |
| haveQ_(ptf.haveQ_), | |
| Q_(ptf.Q_, false), | |
| haveq_(ptf.haveq_), | |
| q_(ptf.q_, false), | |
| h_ | |
| ( | |
| ptf.h_.valid() | |
| ? new FunctionalDimensionedField<scalar, fvPatch> | |
| ( | |
| ptf.h_() | |
| ) | |
| : nullptr | |
| ), | |
| haveEmissivity_(ptf.haveEmissivity_), | |
| emissivity_(ptf.emissivity_), | |
| Ta_(ptf.Ta_, false), | |
| relax_(ptf.relax_), | |
| qrName_(ptf.qrName_), | |
| qrRelax_(ptf.qrRelax_), | |
| qrPrevious_(ptf.qrPrevious_) | |
| {} | |
| Foam::tmp<Foam::fvPatchScalarField> | |
| Foam::externalTemperatureFvPatchScalarField::clone | |
| ( | |
| const DimensionedField<scalar, fvMesh>& iF | |
| ) const | |
| { | |
| return tmp<fvPatchScalarField> | |
| ( | |
| new externalTemperatureFvPatchScalarField(*this, iF) | |
| ); | |
| } | |
| // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // | |
| Foam::externalTemperatureFvPatchScalarField:: | |
| ~externalTemperatureFvPatchScalarField() | |
| {} | |
| // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // | |
| void Foam::externalTemperatureFvPatchScalarField::map | |
| ( | |
| const fvPatchScalarField& ptf, | |
| const fieldMapper& mapper | |
| ) | |
| { | |
| mixedFvPatchScalarField::map(ptf, mapper); | |
| const externalTemperatureFvPatchScalarField& etptf = | |
| refCast<const externalTemperatureFvPatchScalarField>(ptf); | |
| if (h_.valid()) | |
| { | |
| h_->map(etptf.h_(), mapper); | |
| } | |
| if (qrName_ != word::null) | |
| { | |
| mapper(qrPrevious_, etptf.qrPrevious_); | |
| } | |
| } | |
| void Foam::externalTemperatureFvPatchScalarField::reset | |
| ( | |
| const fvPatchScalarField& ptf | |
| ) | |
| { | |
| mixedFvPatchScalarField::reset(ptf); | |
| if (h_.valid()) | |
| { | |
| h_->reset(); | |
| } | |
| const externalTemperatureFvPatchScalarField& tiptf = | |
| refCast<const externalTemperatureFvPatchScalarField>(ptf); | |
| if (qrName_ != word::null) | |
| { | |
| qrPrevious_.reset(tiptf.qrPrevious_); | |
| } | |
| } | |
| void Foam::externalTemperatureFvPatchScalarField::updateCoeffs() | |
| { | |
| if (updated()) | |
| { | |
| return; | |
| } | |
| const scalar t = time().value(); | |
| // Get thermal conductivities, the patch temperature and any explicit | |
| // correction heat flux | |
| scalarField kappa; | |
| tmp<scalarField> sumKappaTcByDelta, sumKappaByDelta; | |
| tmp<scalarField> T; | |
| tmp<scalarField> sumq; | |
| getKappa(kappa, sumKappaTcByDelta, sumKappaByDelta, T, sumq); | |
| // Add any user specified heat fluxes | |
| if (haveQ_) | |
| { | |
| addEqOp(sumq, Q_->value(t)/gSum(patch().magSf())); | |
| } | |
| if (haveq_) | |
| { | |
| addEqOp(sumq, q_->value(t)); | |
| } | |
| // Add the (relaxed) radiative heat flux | |
| if (qrName_ != word::null) | |
| { | |
| const fvPatchScalarField& qrCurrent = | |
| patch().lookupPatchField<volScalarField, scalar>(qrName_); | |
| const scalarField qr(qrRelax_*qrCurrent + (1 - qrRelax_)*qrPrevious_); | |
| qrPrevious_ = qr; | |
| addEqOp(sumq, qr); | |
| } | |
| // Evaluate the ambient temperature | |
| const scalar Ta = h_.valid() || haveEmissivity_ ? Ta_->value(t) : NaN; | |
| // Evaluate the combined convective and radiative heat transfer coefficient | |
| tmp<scalarField> hEff; | |
| if (h_.valid()) | |
| { | |
| h_->update(); | |
| addEqOp(hEff, h_()); | |
| } | |
| if (haveEmissivity_) | |
| { | |
| addEqOp | |
| ( | |
| hEff, | |
| emissivity_ | |
| *constant::physicoChemical::sigma.value() | |
| *(sqr(Ta) + sqr(T())) | |
| *(Ta + T()) | |
| ); | |
| } | |
| // If we have a heat transfer coefficient then add it to the kappa sums | |
| if (hEff.valid()) | |
| { | |
| addEqOp(sumKappaByDelta, hEff()); | |
| addEqOp(sumKappaTcByDelta, hEff*Ta); | |
| } | |
| // Set the mixed parameters | |
| const scalarField kappaByDelta(kappa*patch().deltaCoeffs()); | |
| tmp<scalarField> kappaPlusSumKappaByDelta | |
| ( | |
| sumKappaByDelta.valid() | |
| ? kappaByDelta + sumKappaByDelta() | |
| : tmp<scalarField>(kappaByDelta) | |
| ); | |
| // ... value fraction | |
| if (sumKappaByDelta.valid()) | |
| { | |
| valueFraction() = sumKappaByDelta()/kappaPlusSumKappaByDelta(); | |
| } | |
| else | |
| { | |
| valueFraction() = Zero; | |
| } | |
| // ... reference value | |
| tmp<scalarField> trefValue; | |
| if (sumKappaByDelta.valid()) | |
| { | |
| addEqOp | |
| ( | |
| trefValue, | |
| max(sumKappaTcByDelta, small*kappaByDelta*patchInternalField()) | |
| /max(sumKappaByDelta, small*kappaByDelta) | |
| ); | |
| } | |
| if (sumq.valid()) | |
| { | |
| addEqOp(trefValue, sumq()/kappaPlusSumKappaByDelta()); | |
| } | |
| if (trefValue.valid()) | |
| { | |
| refValue() = trefValue; | |
| } | |
| else | |
| { | |
| refValue() = Zero; | |
| } | |
| // ... and reference gradient | |
| if (sumq.valid()) | |
| { | |
| refGrad() = sumq*patch().deltaCoeffs()/kappaPlusSumKappaByDelta(); | |
| } | |
| else | |
| { | |
| refGrad() = Zero; | |
| } | |
| // Modify the mixed parameters for under-relaxation | |
| if (relax_ != 1) | |
| { | |
| const scalarField f(valueFraction()); | |
| valueFraction() = 1 - relax_*(1 - f); | |
| refValue() = (f*relax_*refValue() + (1 - relax_)*T)/valueFraction(); | |
| } | |
| mixedFvPatchScalarField::updateCoeffs(); | |
| if (debug) | |
| { | |
| const scalar Q = gSum(kappa*patch().magSf()*snGrad()); | |
| Info<< patch().mesh().name() << ':' | |
| << patch().name() << ':' | |
| << this->internalField().name() << " :" | |
| << " heat transfer rate:" << Q | |
| << " walltemperature " | |
| << " min:" << gMin(field()) | |
| << " max:" << gMax(field()) | |
| << " avg:" << gAverage(field()) | |
| << endl; | |
| } | |
| } | |
| void Foam::externalTemperatureFvPatchScalarField::write | |
| ( | |
| Ostream& os | |
| ) const | |
| { | |
| fvPatchScalarField::write(os); | |
| if (haveQ_) | |
| { | |
| writeEntry(os, time().userUnits(), dimensions::power, Q_()); | |
| } | |
| if (haveq_) | |
| { | |
| writeEntry | |
| ( | |
| os, | |
| time().userUnits(), | |
| dimensions::heatFluxDensity, | |
| q_() | |
| ); | |
| } | |
| if (h_.valid()) | |
| { | |
| writeEntry(os, h_()); | |
| } | |
| if (haveEmissivity_) | |
| { | |
| writeEntry(os, "emissivity", emissivity_); | |
| } | |
| if (h_.valid() || haveEmissivity_) | |
| { | |
| writeEntry(os, time().userUnits(), dimensions::temperature, Ta_()); | |
| } | |
| writeEntryIfDifferent(os, "relaxation", scalar(1), relax_); | |
| if (qrName_ != word::null) | |
| { | |
| writeEntry(os, "qr", qrName_); | |
| writeEntry(os, "qrRelaxation", qrRelax_); | |
| writeEntry(os, "qrPrevious", qrPrevious_); | |
| } | |
| writeEntry(os, "refValue", refValue()); | |
| writeEntry(os, "refGradient", refGrad()); | |
| writeEntry(os, "valueFraction", valueFraction()); | |
| writeEntry(os, "value", *this); | |
| } | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| namespace Foam | |
| { | |
| makePatchTypeField | |
| ( | |
| fvPatchScalarField, | |
| externalTemperatureFvPatchScalarField | |
| ); | |
| addBackwardCompatibleToRunTimeSelectionTable | |
| ( | |
| fvPatchScalarField, | |
| externalTemperatureFvPatchScalarField, | |
| patchMapper, | |
| externalWallHeatFluxTemperature, | |
| "externalWallHeatFluxTemperature" | |
| ); | |
| addBackwardCompatibleToRunTimeSelectionTable | |
| ( | |
| fvPatchScalarField, | |
| externalTemperatureFvPatchScalarField, | |
| dictionary, | |
| externalWallHeatFluxTemperature, | |
| "externalWallHeatFluxTemperature" | |
| ); | |
| } | |
| // ************************************************************************* // | |