thermalBaffle1DFvPatchScalarField<solidType>:: thermalBaffle1DFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mappedPatchBase ( p.patch(), p.boundaryMesh().mesh().name(), NEARESTPATCHFACE, dict.lookup("samplePatch"), 0.0 ), mixedFvPatchScalarField(p, iF), TName_("T"), baffleActivated_(dict.lookupOrDefault<bool>("baffleActivated", true)), thickness_(), Qs_(p.size(), 0), solidDict_(dict), solidPtr_(), QrPrevious_(p.size(), 0.0), QrRelaxation_(dict.lookupOrDefault<scalar>("relaxation", 0)), QrName_(dict.lookupOrDefault<word>("Qr", "none")) { fvPatchScalarField::operator=(scalarField("value", dict, p.size())); if (dict.found("thickness")) { thickness_ = scalarField("thickness", dict, p.size()); } if (dict.found("Qs")) { Qs_ = scalarField("Qs", dict, p.size()); } if (dict.found("QrPrevious")) { QrPrevious_ = scalarField("QrPrevious", dict, p.size()); } if (dict.found("refValue") && baffleActivated_) { // Full restart refValue() = scalarField("refValue", dict, p.size()); refGrad() = scalarField("refGradient", dict, p.size()); valueFraction() = scalarField("valueFraction", dict, p.size()); } else { // Start from user entered data. Assume zeroGradient. refValue() = *this; refGrad() = 0.0; valueFraction() = 0.0; } }
filmPyrolysisRadiativeCoupledMixedFvPatchScalarField:: filmPyrolysisRadiativeCoupledMixedFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), temperatureCoupledBase(patch(), dict), filmRegionName_ ( dict.lookupOrDefault<word>("filmRegion", "surfaceFilmProperties") ), pyrolysisRegionName_ ( dict.lookupOrDefault<word>("pyrolysisRegion", "pyrolysisProperties") ), TnbrName_(dict.lookup("Tnbr")), QrName_(dict.lookup("Qr")), convectiveScaling_(dict.lookupOrDefault<scalar>("convectiveScaling", 1.0)), filmDeltaDry_(readScalar(dict.lookup("filmDeltaDry"))), filmDeltaWet_(readScalar(dict.lookup("filmDeltaWet"))) { if (!isA<mappedPatchBase>(this->patch().patch())) { FatalErrorIn ( "filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::" "filmPyrolysisRadiativeCoupledMixedFvPatchScalarField\n" "(\n" " const fvPatch& p,\n" " const DimensionedField<scalar, volMesh>& iF,\n" " const dictionary& dict\n" ")\n" ) << "\n patch type '" << p.type() << "' not type '" << mappedPatchBase::typeName << "'" << "\n for patch " << p.name() << " of field " << dimensionedInternalField().name() << " in file " << dimensionedInternalField().objectPath() << exit(FatalError); } fvPatchScalarField::operator=(scalarField("value", dict, p.size())); if (dict.found("refValue")) { // Full restart refValue() = scalarField("refValue", dict, p.size()); refGrad() = scalarField("refGradient", dict, p.size()); valueFraction() = scalarField("valueFraction", dict, p.size()); } else { // Start from user entered data. Assume fixedValue. refValue() = *this; refGrad() = 0.0; valueFraction() = 1.0; } }
CFDHAMfluidMoistureCoupledMixedFvPatchScalarField:: CFDHAMfluidMoistureCoupledMixedFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), temperatureCoupledBase(patch(), dict), wnbrName_(dict.lookupOrDefault<word>("wnbr", "none")), TnbrName_(dict.lookupOrDefault<word>("Tnbr", "none")), QrNbrName_(dict.lookupOrDefault<word>("QrNbr", "none")), QrName_(dict.lookupOrDefault<word>("Qr", "none")), QsNbrName_(dict.lookupOrDefault<word>("QsNbr", "none")), QsName_(dict.lookupOrDefault<word>("Qs", "none")) { if (!isA<mappedPatchBase>(this->patch().patch())) { FatalErrorIn ( "CFDHAMfluidMoistureCoupledMixedFvPatchScalarField::" "CFDHAMfluidMoistureCoupledMixedFvPatchScalarField\n" "(\n" " const fvPatch& p,\n" " const DimensionedField<scalar, volMesh>& iF,\n" " const dictionary& dict\n" ")\n" ) << "\n patch type '" << p.type() << "' not type '" << mappedPatchBase::typeName << "'" << "\n for patch " << p.name() << " of field " << dimensionedInternalField().name() << " in file " << dimensionedInternalField().objectPath() << exit(FatalError); } fvPatchScalarField::operator=(scalarField("value", dict, p.size())); if (dict.found("refValue")) { // Full restart refValue() = scalarField("refValue", dict, p.size()); refGrad() = scalarField("refGradient", dict, p.size()); valueFraction() = scalarField("valueFraction", dict, p.size()); } else { // Start from user entered data. Assume fixedValue. refValue() = *this; refGrad() = 0.0; valueFraction() = 1.0; } }
thermalBaffle1DFvPatchScalarField<solidType>:: thermalBaffle1DFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), TName_("T"), baffleActivated_(readBool(dict.lookup("baffleActivated"))), thickness_(scalarField("thickness", dict, p.size())), Qs_(scalarField("Qs", dict, p.size())), solidDict_(dict), solidPtr_(new solidType(dict)) { if (!isA<mappedPatchBase>(this->patch().patch())) { FatalErrorIn ( "thermalBaffle1DFvPatchScalarField::" "thermalBaffle1DFvPatchScalarField" "(" "const fvPatch&,\n" "const DimensionedField<scalar, volMesh>&, " "const dictionary&" ")" ) << "\n patch type '" << patch().type() << "' not type '" << mappedPatchBase::typeName << "'" << "\n for patch " << patch().name() << " of field " << dimensionedInternalField().name() << " in file " << dimensionedInternalField().objectPath() << exit(FatalError); } fvPatchScalarField::operator=(scalarField("value", dict, p.size())); if (dict.found("refValue") && baffleActivated_) { // Full restart refValue() = scalarField("refValue", dict, p.size()); refGrad() = scalarField("refGradient", dict, p.size()); valueFraction() = scalarField("valueFraction", dict, p.size()); } else { // Start from user entered data. Assume zeroGradient. refValue() = *this; refGrad() = 0.0; valueFraction() = 0.0; } }
surfaceChargeCoupledFvPatchScalarField:: surfaceChargeCoupledFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), temperatureCoupledBase(patch(), dict), neighbourFieldName_(dict.lookup("neighbourFieldName")), surfCharge_(readScalar(dict.lookup("surfaceCharge"))), myEpr_(readScalar(dict.lookup("myEpr"))), nbrEpr_(readScalar(dict.lookup("nbrEpr"))) { if (!isA<mappedPatchBase>(this->patch().patch())) { FatalErrorIn ( "surfaceChargeCoupledFvPatchScalarField::" "surfaceChargeCoupledFvPatchScalarField\n" "(\n" " const fvPatch& p,\n" " const DimensionedField<scalar, volMesh>& iF,\n" " const dictionary& dict\n" ")\n" ) << "\n patch type '" << p.type() << "' not type '" << mappedPatchBase::typeName << "'" << "\n for patch " << p.name() << " of field " << dimensionedInternalField().name() << " in file " << dimensionedInternalField().objectPath() << exit(FatalError); } fvPatchScalarField::operator=(scalarField("value", dict, p.size())); if (dict.found("refValue")) { // Full restart refValue() = scalarField("refValue", dict, p.size()); refGrad() = scalarField("refGradient", dict, p.size()); valueFraction() = scalarField("valueFraction", dict, p.size()); } else { // Start from user entered data. Assume fixedValue. refValue() = *this; refGrad() = 0.0; valueFraction() = 1.0; } }
void Foam::mixedInternalEnergyFvPatchScalarField::updateCoeffs() { if (updated()) { return; } const basicThermo& thermo = db().lookupObject<basicThermo> ( "thermophysicalProperties" ); const label patchi = patch().index(); mixedFvPatchScalarField& Tw = refCast<mixedFvPatchScalarField> ( const_cast<fvPatchScalarField&>(thermo.T().boundaryField()[patchi]) ); Tw.evaluate(); valueFraction() = Tw.valueFraction(); refValue() = thermo.e(Tw.refValue(), patchi); refGrad() = thermo.Cv(Tw, patchi)*Tw.refGrad() + patch().deltaCoeffs()* ( thermo.e(Tw, patchi) - thermo.e(Tw, patch().faceCells()) ); mixedFvPatchScalarField::updateCoeffs(); }
Foam::MarshakRadiationFixedTMixedFvPatchScalarField:: MarshakRadiationFixedTMixedFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), Trad_("Trad", dict, p.size()), emissivity_(readScalar(dict.lookup("emissivity"))) { refValue() = 4.0*radiation::sigmaSB.value()*pow4(Trad_); refGrad() = 0.0; if (dict.found("value")) { fvPatchScalarField::operator= ( scalarField("value", dict, p.size()) ); } else { fvPatchScalarField::operator=(refValue()); } }
Foam::constHTemperatureFvPatchScalarField:: constHTemperatureFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchField<scalar>(p, iF), Tinf_("Tinf", dict, p.size()), h_("h", dict, p.size()) { refValue() = Tinf_; refGrad() = 0.0; valueFraction() = 0.0; if (dict.found("value")) { fvPatchField<scalar>::operator= ( Field<scalar>("value", dict, p.size()) ); } else { fvPatchField<scalar>::operator=(refValue()); } }
void Foam::constHTemperatureFvPatchScalarField::updateCoeffs() { if (this->updated()) { return; } // scalarField K_ = patch().lookupPatchField<volScalarField, scalar>("K"); const fvMesh& mesh = patch().boundaryMesh().mesh(); const solidThermo& thermo = mesh.lookupObject<solidThermo>("thermophysicalProperties"); scalarField K_(thermo.kappa(patch().index())); refValue() = Tinf_; refGrad() = 0.0; valueFraction() = 1.0/(1.0 + K_/max(h_,SMALL)*patch().deltaCoeffs()); mixedFvPatchField<scalar>::updateCoeffs(); }
solidDirectionMixedFvPatchVectorField::solidDirectionMixedFvPatchVectorField ( const fvPatch& p, const DimensionedField<vector, volMesh>& iF, const dictionary& dict ) : directionMixedFvPatchVectorField(p, iF, dict), fieldName_(dimensionedInternalField().name()) { Field<vector> normalValue = transform(valueFraction(), refValue()); Field<vector> gradValue = this->patchInternalField() + refGrad()/this->patch().deltaCoeffs(); //- non-ortho corrected gradValue //- gradField will not have been created so I must do this during updateCoeffs /*const fvPatchField<tensor>& gradField = patch().lookupPatchField<volTensorField, tensor>("grad(" +fieldName_ + ")"); vectorField n = patch().nf(); vectorField delta = patch().delta(); vectorField k = delta - n*(n&delta); Field<vector> gradValue = this->patchInternalField() + (k&gradField.patchInternalField()) + refGrad()/this->patch().deltaCoeffs(); */ Field<vector> transformGradValue = transform(I - valueFraction(), gradValue); Field<vector>::operator=(normalValue + transformGradValue); }
void mixedUnburntEnthalpyFvPatchScalarField::updateCoeffs() { if (updated()) { return; } const hhuCombustionThermo& thermo = db().lookupObject<hhuCombustionThermo> ( "thermophysicalProperties" ); const label patchi = patch().index(); mixedFvPatchScalarField& Tw = refCast<mixedFvPatchScalarField> ( const_cast<fvPatchScalarField&>(thermo.Tu().boundaryField()[patchi]) ); Tw.evaluate(); valueFraction() = Tw.valueFraction(); refValue() = thermo.hu(Tw.refValue(), patchi); refGrad() = thermo.Cp(Tw, patchi)*Tw.refGrad() + patch().deltaCoeffs()* ( thermo.hu(Tw, patchi) - thermo.hu(Tw, patch().faceCells()) ); mixedFvPatchScalarField::updateCoeffs(); }
// Update the coefficients associated with the patch field void nusseltFvPatchScalarField::updateCoeffs() { if (updated()) { return; } scalarField Tinternal = patchInternalField(); // Lookup temperature diffusivity of the patch const fvPatchField<scalar>& DT = this->patch().lookupPatchField<volScalarField, scalar>(DTName_); // Calculate flux scalarField tempFlux = alpha_*(Tinternal - Tinf_); refValue() = neg(tempFlux)* min ( Tinternal - tempFlux/(DT*patch().deltaCoeffs()), Tinf_ ) + pos(tempFlux)* max ( Tinternal - tempFlux/(DT*patch().deltaCoeffs()), Tinf_ ); refGrad() = -tempFlux; valueFraction() = pos(tempFlux); mixedFvPatchScalarField::updateCoeffs(); }
Foam::fixedEnthalpyFluxTemperatureFvPatchScalarField:: fixedEnthalpyFluxTemperatureFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchField<scalar>(p, iF), phiName_(dict.lookupOrDefault<word>("phi", "phi")), rhoName_(dict.lookupOrDefault<word>("rho", "none")), Tinf_("Tinf", dict, p.size()) { refValue() = Tinf_; refGrad() = 0.0; valueFraction() = 0.0; if (dict.found("value")) { fvPatchField<scalar>::operator= ( Field<scalar>("value", dict, p.size()) ); } else { fvPatchField<scalar>::operator=(refValue()); } }
void solidDirectionMixedFvPatchVectorField::evaluate(const Pstream::commsTypes) { if (!this->updated()) { this->updateCoeffs(); } Field<vector> normalValue = transform(valueFraction(), refValue()); //- no correction //Field<vector> gradValue = //this->patchInternalField() + refGrad()/this->patch().deltaCoeffs(); //- non-ortho corrected gradValue const fvPatchField<tensor>& gradField = patch().lookupPatchField<volTensorField, tensor> ( "grad(" +fieldName_ + ")" ); vectorField n = patch().nf(); vectorField delta = patch().delta(); vectorField k = delta - n*(n&delta); Field<vector> gradValue = this->patchInternalField() + (k&gradField.patchInternalField()) + refGrad()/this->patch().deltaCoeffs(); Field<vector> transformGradValue = transform(I - valueFraction(), gradValue); Field<vector>::operator=(normalValue + transformGradValue); fvPatchField<vector>::evaluate(); }
Foam::MarshakRadiationFvPatchScalarField::MarshakRadiationFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), radiationCoupledBase(p, dict), TName_(dict.lookupOrDefault<word>("T", "T")) { if (dict.found("value")) { refValue() = scalarField("value", dict, p.size()); } else { refValue() = 0.0; } // zero gradient refGrad() = 0.0; valueFraction() = 1.0; fvPatchScalarField::operator=(refValue()); }
Foam::wallHeatTransferFvPatchScalarField::wallHeatTransferFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), Tinf_("Tinf", dict, p.size()), alphaWall_("alphaWall", dict, p.size()) { refValue() = Tinf_; refGrad() = 0.0; valueFraction() = 0.0; if (dict.found("value")) { fvPatchField<scalar>::operator= ( scalarField("value", dict, p.size()) ); } else { evaluate(); } }
Foam::totalFlowRateAdvectiveDiffusiveFvPatchScalarField:: totalFlowRateAdvectiveDiffusiveFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchField<scalar>(p, iF), phiName_(dict.lookupOrDefault<word>("phi", "phi")), rhoName_(dict.lookupOrDefault<word>("rho", "none")), massFluxFraction_(dict.lookupOrDefault<scalar>("massFluxFraction", 1.0)) { refValue() = 1.0; refGrad() = 0.0; valueFraction() = 0.0; if (dict.found("value")) { fvPatchField<scalar>::operator= ( Field<scalar>("value", dict, p.size()) ); } else { fvPatchField<scalar>::operator=(refValue()); } }
nusseltFvPatchScalarField::nusseltFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), DTName_(dict.lookup("DT")), Tinf_(readScalar(dict.lookup("Tinf"))), alpha_("alpha", dict, p.size()) { if (dict.found("value")) { fvPatchField<scalar>::operator= ( scalarField("value", dict, p.size()) ); } else { fvPatchField<scalar>::operator=(patchInternalField()); } refValue() = *this; refGrad() = 0.0; valueFraction() = 0.0; if (Tinf_ < SMALL) { FatalIOErrorIn ( "nusseltFvPatchScalarField::nusseltFvPatchScalarField\n" "(\n" " const fvPatch&,\n" " const DimensionedField<scalar, volMesh>&,\n" " const dictionary&\n" ")", dict ) << "unphysical Tinf specified (Tinf = 0 or negative)" << exit(FatalError); } if (min(alpha_) < -SMALL) { FatalIOErrorIn ( "nusseltFvPatchScalarField::nusseltFvPatchScalarField\n" "(\n" " const fvPatch&,\n" " const DimensionedField<scalar, volMesh>&,\n" " const dictionary&\n" ")", dict ) << "unphysical alpha specified (alpha = 0 or negative)" << endl << exit(FatalError); } }
smoluchowskiJumpTFvPatchScalarField::smoluchowskiJumpTFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), accommodationCoeff_(readScalar(dict.lookup("accommodationCoeff"))), Twall_("Twall", dict, p.size()) { if ( mag(accommodationCoeff_) < SMALL || mag(accommodationCoeff_) > 2.0 ) { FatalIOErrorIn ( "smoluchowskiJumpTFvPatchScalarField::" "smoluchowskiJumpTFvPatchScalarField" "(" " const fvPatch&," " const DimensionedField<scalar, volMesh>&," " const dictionary&" ")", dict ) << "unphysical accommodationCoeff_ specified" << "(0 < accommodationCoeff_ <= 1)" << endl << exit(FatalError); } if (dict.found("value")) { fvPatchField<scalar>::operator= ( scalarField("value", dict, p.size()) ); } else { fvPatchField<scalar>::operator=(patchInternalField()); } if (dict.found("gamma")) { gamma_ = readScalar(dict.lookup("gamma")); } else { gamma_ = 1.4; } refValue() = *this; refGrad() = 0.0; valueFraction() = 0.0; }
greyDiffusiveRadiationMixedFvPatchScalarField:: greyDiffusiveRadiationMixedFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), TName_(dict.lookup("T")), emissivity_(readScalar(dict.lookup("emissivity"))), sumOutgoingAnglesPtr_(NULL) { if (dict.found("refValue")) { refValue() = scalarField("value", dict, p.size()); fvPatchScalarField::operator= ( refValue() ); refGrad() = scalarField("refGradient", dict, p.size()); valueFraction() = scalarField("valueFraction", dict, p.size()); } else { // No value given. Restart as fixedValue b.c. // Bugfix: Do not initialize from temperautre because it is unavailable // when running, e.g. decomposePar and loading radiation as // shared library. Initialize to zero instead. // 26 Mar 2014 - DC refValue() = 0; refGrad() = 0; valueFraction() = 1; fvPatchScalarField::operator=(refValue()); } }
mixedUnburntEnthalpyFvPatchScalarField::mixedUnburntEnthalpyFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF ) : mixedFvPatchScalarField(p, iF) { valueFraction() = 0.0; refValue() = 0.0; refGrad() = 0.0; }
mixedInternalEnergyFvPatchScalarField::mixedInternalEnergyFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF ) : mixedFvPatchScalarField(p, iF) { valueFraction() = 0.0; refValue() = 0.0; refGrad() = 0.0; }
Foam::smoluchowskiJumpTFvPatchScalarField::smoluchowskiJumpTFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), UName_(dict.lookupOrDefault<word>("U", "U")), rhoName_(dict.lookupOrDefault<word>("rho", "rho")), psiName_(dict.lookupOrDefault<word>("psi", "thermo:psi")), muName_(dict.lookupOrDefault<word>("mu", "thermo:mu")), accommodationCoeff_(readScalar(dict.lookup("accommodationCoeff"))), Twall_("Twall", dict, p.size()), gamma_(dict.lookupOrDefault<scalar>("gamma", 1.4)) { if ( mag(accommodationCoeff_) < SMALL || mag(accommodationCoeff_) > 2.0 ) { FatalIOErrorIn ( "smoluchowskiJumpTFvPatchScalarField::" "smoluchowskiJumpTFvPatchScalarField" "(" " const fvPatch&," " const DimensionedField<scalar, volMesh>&," " const dictionary&" ")", dict ) << "unphysical accommodationCoeff specified" << "(0 < accommodationCoeff <= 1)" << endl << exit(FatalIOError); } if (dict.found("value")) { fvPatchField<scalar>::operator= ( scalarField("value", dict, p.size()) ); } else { fvPatchField<scalar>::operator=(patchInternalField()); } refValue() = *this; refGrad() = 0.0; valueFraction() = 0.0; }
Foam::radiation::greyDiffusiveRadiationMixedFvPatchScalarField:: greyDiffusiveRadiationMixedFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF, const dictionary& dict ) : mixedFvPatchScalarField(p, iF), TName_(dict.lookup("T")), emissivity_(readScalar(dict.lookup("emissivity"))) { if (dict.found("refValue")) { fvPatchScalarField::operator= ( scalarField("value", dict, p.size()) ); refValue() = scalarField("refValue", dict, p.size()); refGrad() = scalarField("refGradient", dict, p.size()); valueFraction() = scalarField("valueFraction", dict, p.size()); } else { // No value given. Restart as fixedValue b.c. const scalarField& Tp = patch().lookupPatchField<volScalarField, scalar>(TName_); refValue() = emissivity_*4.0*radiation::sigmaSB.value()*pow4(Tp) /Foam::mathematicalConstant::pi; refGrad() = 0.0; valueFraction() = 1.0; fvPatchScalarField::operator=(refValue()); } }
Foam::MarshakRadiationFvPatchScalarField::MarshakRadiationFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF ) : mixedFvPatchScalarField(p, iF), radiationCoupledBase(p, "undefined", scalarField::null()), TName_("T") { refValue() = 0.0; refGrad() = 0.0; valueFraction() = 0.0; }
Foam::wallHeatTransferFvPatchScalarField::wallHeatTransferFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF ) : mixedFvPatchScalarField(p, iF), Tinf_(p.size(), 0.0), alphaWall_(p.size(), 0.0) { refValue() = 0.0; refGrad() = 0.0; valueFraction() = 0.0; }
void timeVaryingFixedDisplacementZeroShearFvPatchVectorField::updateCoeffs() { if (this->updated()) { return; } // set refValue vectorField disp ( patch().size(), timeSeries_(this->db().time().timeOutputValue()) ); if (fieldName_ == "DU") { const fvPatchField<vector>& U = patch().lookupPatchField<volVectorField, vector>("U"); disp -= U; } else if (fieldName_ != "U") { FatalError << "The displacement field should be U or DU" << exit(FatalError); } this->refValue() = disp; // set value fraction to fix reference patch normal // only done at initialisation above //vectorField n = patch().nf(); //this->valueFraction() = sqr(n); bool incremental(fieldName_ == "DU"); refGrad() = tractionBoundaryGradient::snGrad ( vectorField(patch().size(), vector::zero), scalarField(patch().size(), 0), fieldName_, "U", patch(), orthotropic_, nonLinear_, incremental ); directionMixedFvPatchVectorField::updateCoeffs(); }
Foam::smoluchowskiJumpTFvPatchScalarField::smoluchowskiJumpTFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF ) : mixedFvPatchScalarField(p, iF), accommodationCoeff_(1.0), Twall_(p.size(), 0.0), gamma_(1.4) { refValue() = 0.0; refGrad() = 0.0; valueFraction() = 0.0; }
Foam::pressureInletOutletParSlipVelocityFvPatchVectorField:: pressureInletOutletParSlipVelocityFvPatchVectorField ( const fvPatch& p, const DimensionedField<vector, volMesh>& iF ) : mixedFvPatchVectorField(p, iF), phiName_("phi"), rhoName_("rho") { refValue() = *this; refGrad() = Zero; valueFraction() = 0.0; }
nusseltFvPatchScalarField::nusseltFvPatchScalarField ( const fvPatch& p, const DimensionedField<scalar, volMesh>& iF ) : mixedFvPatchScalarField(p, iF), DTName_("undefined"), Tinf_(0.0), alpha_(p.size(), 0.0) { refValue() = 0.0; refGrad() = 0.0; valueFraction() = 0.0; }