void calcYPlus ( const TurbulenceModel& turbulenceModel, const fvMesh& mesh, const volVectorField& U, volScalarField& yPlus ) { volScalarField::GeometricBoundaryField d = nearWallDist(mesh).y(); const volScalarField::GeometricBoundaryField nutBf = turbulenceModel->nut()().boundaryField(); const volScalarField::GeometricBoundaryField nuEffBf = turbulenceModel->nuEff()().boundaryField(); const volScalarField::GeometricBoundaryField nuBf = turbulenceModel->nu()().boundaryField(); const fvPatchList& patches = mesh.boundary(); forAll(patches, patchi) { const fvPatch& patch = patches[patchi]; if (isA<nutWallFunctionFvPatchScalarField>(nutBf[patchi])) { const nutWallFunctionFvPatchScalarField& nutPf = dynamic_cast<const nutWallFunctionFvPatchScalarField&> ( nutBf[patchi] ); yPlus.boundaryField()[patchi] = nutPf.yPlus(); const scalarField& Yp = yPlus.boundaryField()[patchi]; Info<< "Patch " << patchi << " named " << nutPf.patch().name() << ", wall-function " << nutPf.type() << ", y+ : min: " << gMin(Yp) << " max: " << gMax(Yp) << " average: " << gAverage(Yp) << nl << endl; } else if (isA<wallFvPatch>(patch)) { yPlus.boundaryField()[patchi] = d[patchi] *sqrt ( nuEffBf[patchi] *mag(U.boundaryField()[patchi].snGrad()) )/nuBf[patchi]; const scalarField& Yp = yPlus.boundaryField()[patchi]; Info<< "Patch " << patchi << " named " << patch.name() << " y+ : min: " << gMin(Yp) << " max: " << gMax(Yp) << " average: " << gAverage(Yp) << nl << endl; } } }
void Foam::componentDisplacementMotionSolver::updateMesh(const mapPolyMesh& mpm) { // pointMesh already updates pointFields. motionSolver::updateMesh(mpm); // Map points0_. Bit special since we somehow have to come up with // a sensible points0 position for introduced points. // Find out scaling between points0 and current points // Get the new points either from the map or the mesh const scalarField points ( mpm.hasMotionPoints() ? mpm.preMotionPoints().component(cmpt_) : mesh().points().component(cmpt_) ); // Get extents of points0 and points and determine scale const scalar scale = (gMax(points0_)-gMin(points0_)) /(gMax(points)-gMin(points)); scalarField newPoints0(mpm.pointMap().size()); forAll(newPoints0, pointI) { label oldPointI = mpm.pointMap()[pointI]; if (oldPointI >= 0) { label masterPointI = mpm.reversePointMap()[oldPointI]; if (masterPointI == pointI) { newPoints0[pointI] = points0_[oldPointI]; } else { // New point. Assume motion is scaling. newPoints0[pointI] = points0_[oldPointI] + scale*(points[pointI]-points[masterPointI]); } } else { FatalErrorIn ( "displacementLaplacianFvMotionSolver::updateMesh" "(const mapPolyMesh& mpm)" ) << "Cannot work out coordinates of introduced vertices." << " New vertex " << pointI << " at coordinate " << points[pointI] << exit(FatalError); } }
ErrVal VUI::InitHrd( UInt uiIndex, HRD::HrdParamType eHrdType, UInt uiBitRate, UInt uiCpbSize) { HRD& rcHrd = (eHrdType == HRD::NAL_HRD) ? m_acNalHrd[uiIndex] : m_acVclHrd[uiIndex]; if( rcHrd.getHrdParametersPresentFlag()) { // we provide only one set of parameters. the following code is pretty hard coded rcHrd.setCpbCnt(1); UInt uiExponentBR = gMax(6, gGetNumberOfLSBZeros(uiBitRate)); UInt uiExponentCpb = gMax(4, gGetNumberOfLSBZeros(uiCpbSize)); rcHrd.setBitRateScale(uiExponentBR-6); rcHrd.setCpbSizeScale(uiExponentCpb-4); rcHrd.init(1); for( UInt CpbCnt=0; CpbCnt<1; CpbCnt++) { Int iBitNumLSBZeros = gGetNumberOfLSBZeros(uiBitRate); Int iCpbNumLSBZeros = gGetNumberOfLSBZeros(uiCpbSize); // we're doing a bit complicated rounding here to find the nearest value // probably we should use the exact or bigger bit rate value: //for values with 6 or more LSBZeros: if( iBitNumLSBZeros >= 5) { rcHrd.getCntBuf(CpbCnt).setBitRateValue((UInt)floor ( ((Double)(uiBitRate) / (1 << uiExponentBR)))); } else//for values with less than 6 LSBZeros { rcHrd.getCntBuf(CpbCnt).setBitRateValue((UInt)floor ( ((Double)(uiBitRate) / (1 << uiExponentBR)) + 0.5)); } //for values with 4 or more LSBZeros: if( iCpbNumLSBZeros >= 3) { rcHrd.getCntBuf(CpbCnt).setCpbSizeValue((UInt)floor ( ((Double)(uiCpbSize) / (1<< uiExponentCpb)) )); } else//for values with less than 4 LSBZeros { rcHrd.getCntBuf(CpbCnt).setCpbSizeValue((UInt)floor ( ((Double)(uiCpbSize) / (1<< uiExponentCpb)) + 0.5)); } //0 VBR 1 CBR rcHrd.getCntBuf(CpbCnt).setVbrCbrFlag(0);// 1: stuffing needed } rcHrd.setInitialCpbRemovalDelayLength(24); rcHrd.setCpbRemovalDelayLength(24); rcHrd.setDpbOutputDelayLength(24); rcHrd.setTimeOffsetLength(0); } return Err::m_nOK; }
bool toNormalizedRGB(float& _nr, float& _ng, float& _nb) const { _nr = range(0.0f, m_r / rMax(), 1.0f); _ng = range(0.0f, m_g / gMax(), 1.0f); _nb = range(0.0f, m_b / bMax(), 1.0f); return true; }
bool fromNormalizedRGB(const float& _nr, const float& _ng, const float& _nb) { m_r = _nr * rMax(); m_g = _ng * gMax(); m_b = _nb * bMax(); return true; }
void Foam::bound(volScalarField& vsf, const dimensionedScalar& vsf0) { scalar minVsf = min(vsf).value(); if (minVsf < vsf0.value()) { Info<< "bounding " << vsf.name() << ", min: " << gMin(vsf.internalField()) << " max: " << gMax(vsf.internalField()) << " average: " << gAverage(vsf.internalField()) << endl; vsf.internalField() = max ( max ( vsf.internalField(), fvc::average(max(vsf, vsf0))().internalField() // Bug fix: was assuming bound on zero. HJ, 25/Nov/2008 *pos(vsf0.value() - vsf.internalField()) ), vsf0.value() ); vsf.correctBoundaryConditions(); vsf.boundaryField() = max(vsf.boundaryField(), vsf0.value()); } }
forAllConstIter(labelHashSet, patchSet_, iter) { label patchi = iter.key(); const polyPatch& pp = mesh.boundaryMesh()[patchi]; vectorField& ssp = shearStress.boundaryFieldRef()[patchi]; const vectorField& Sfp = mesh.Sf().boundaryField()[patchi]; const scalarField& magSfp = mesh.magSf().boundaryField()[patchi]; const symmTensorField& Reffp = Reff.boundaryField()[patchi]; ssp = (-Sfp/magSfp) & Reffp; vector minSsp = gMin(ssp); vector maxSsp = gMax(ssp); if (Pstream::master()) { file() << mesh.time().value() << token::TAB << pp.name() << token::TAB << minSsp << token::TAB << maxSsp << endl; } if (log_) Info<< " min/max(" << pp.name() << ") = " << minSsp << ", " << maxSsp << endl; }
Foam::scalar Foam::solidRegionDiffNo ( const fvMesh& mesh, const Time& runTime, const volScalarField& Cprho, const volScalarField& kappa ) { scalar DiNum = 0.0; scalar meanDiNum = 0.0; //- Take care: can have fluid domains with 0 cells so do not test for // zero internal faces. surfaceScalarField kapparhoCpbyDelta ( mesh.surfaceInterpolation::deltaCoeffs() * fvc::interpolate(kappa) / fvc::interpolate(Cprho) ); DiNum = gMax(kapparhoCpbyDelta.internalField())*runTime.deltaT().value(); meanDiNum = (average(kapparhoCpbyDelta)).value()*runTime.deltaT().value(); Info<< "Region: " << mesh.name() << " Diffusion Number mean: " << meanDiNum << " max: " << DiNum << endl; return DiNum; }
void Foam::solidWallHeatFluxTemperatureFvPatchScalarField::updateCoeffs() { if (updated()) { return; } gradient() = q_/K(); fixedGradientFvPatchScalarField::updateCoeffs(); if (debug) { scalar Q = gSum(K()*patch().magSf()*snGrad()); Info<< patch().boundaryMesh().mesh().name() << ':' << patch().name() << ':' << this->dimensionedInternalField().name() << " :" << " heatFlux:" << Q << " walltemperature " << " min:" << gMin(*this) << " max:" << gMax(*this) << " avg:" << gAverage(*this) << endl; } }
void Foam::yPlusRAS::calcIncompressibleYPlus ( const fvMesh& mesh, volScalarField& yPlus ) { typedef incompressible::nutWallFunctionFvPatchScalarField wallFunctionPatchField; const incompressible::RASModel& model = mesh.lookupObject<incompressible::RASModel>("RASProperties"); const volScalarField nut(model.nut()); const volScalarField::GeometricBoundaryField& nutPatches = nut.boundaryField(); bool foundPatch = false; forAll(nutPatches, patchI) { if (isA<wallFunctionPatchField>(nutPatches[patchI])) { foundPatch = true; const wallFunctionPatchField& nutPw = dynamic_cast<const wallFunctionPatchField&>(nutPatches[patchI]); yPlus.boundaryField()[patchI] = nutPw.yPlus(); const scalarField& Yp = yPlus.boundaryField()[patchI]; scalar minYp = gMin(Yp); scalar maxYp = gMax(Yp); scalar avgYp = gAverage(Yp); if (log_) { Info<< " patch " << nutPw.patch().name() << " y+ : min = " << minYp << ", max = " << maxYp << ", average = " << avgYp << nl; } if (Pstream::master()) { file() << obr_.time().value() << token::TAB << nutPw.patch().name() << token::TAB << minYp << token::TAB << maxYp << token::TAB << avgYp << endl; } } } if (log_ && !foundPatch) { Info<< " no " << wallFunctionPatchField::typeName << " patches" << endl; } }
void Foam::boundMinMax ( volScalarField& vsf, const dimensionedScalar& vsf0, const dimensionedScalar& vsf1 ) { scalar minVsf = min(vsf).value(); scalar maxVsf = max(vsf).value(); if (minVsf < vsf0.value() || maxVsf > vsf1.value()) { Info<< "bounding " << vsf.name() << ", min: " << gMin(vsf.internalField()) << " max: " << gMax(vsf.internalField()) << " average: " << gAverage(vsf.internalField()) << endl; } if (minVsf < vsf0.value()) { vsf.internalField() = max ( max ( vsf.internalField(), fvc::average(max(vsf, vsf0))().internalField() *pos(vsf0.value() - vsf.internalField()) ), vsf0.value() ); vsf.correctBoundaryConditions(); vsf.boundaryField() = max(vsf.boundaryField(), vsf0.value()); } if (maxVsf > vsf1.value()) { vsf.internalField() = min ( min ( vsf.internalField(), fvc::average(min(vsf, vsf1))().internalField() *neg(vsf1.value() - vsf.internalField()) // This is needed when all values are above max // HJ, 18/Apr/2009 + pos(vsf1.value() - vsf.internalField())*vsf1.value() ), vsf1.value() ); vsf.correctBoundaryConditions(); vsf.boundaryField() = min(vsf.boundaryField(), vsf1.value()); } }
UInt MbTransformCoeffs::calcCoeffCount( ChromaIdx cChromaIdx, const UChar *pucScan, UInt uiStart, UInt uiStop ) const { const TCoeff *piCoeff = get( cChromaIdx ); UInt uiCount = 0; for( UInt ui = gMax( 1, uiStart ); ui < uiStop; ui++ ) { if( piCoeff[pucScan[ui]] ) uiCount++; } return uiCount; }
int main(int argc, char *argv[]) { #include "postProcess.H" #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" #include "createControl.H" label inlet = mesh.boundaryMesh().findPatchID("Inlet"); label outlet = mesh.boundaryMesh().findPatchID("Outlet"); #include "createFields.H" #include "createFvOptions.H" #include "initContinuityErrs.H" turbulence->validate(); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting Iteration loop\n" << endl; while (simple.loop()) { Info<< "Iteration Number = " << runTime.timeName() << nl << endl; // Pressure-velocity SIMPLE corrector { #include "UEqn.H" #include "EEqn.H" #include "pEqn.H" } turbulence->correct(); runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << endl; Info<< "Inflow : " << -1.0* gSum( phi.boundaryField()[inlet] ) <<" [kg/s]" << endl; Info<< "Outflow : " << gSum( phi.boundaryField()[outlet] ) <<" [kg/s]" << endl; Info<< "EnergyInflow : " << -1.0* gSum( phi.boundaryField()[inlet] * ( thermo.he().boundaryField()[inlet] + 0.5*magSqr(U.boundaryField()[inlet]) ) ) <<" [W]" << endl; Info<< "EnergyOutflow : " << gSum( phi.boundaryField()[outlet] * ( thermo.he().boundaryField()[outlet] + 0.5*magSqr(U.boundaryField()[outlet]) ) ) <<" [W]" << endl; Info<< "EnergyBalance : " << gSum( phi.boundaryField()[outlet] * ( thermo.he().boundaryField()[outlet] + 0.5*magSqr(U.boundaryField()[outlet]) ) ) +1.0* gSum( phi.boundaryField()[inlet] * ( thermo.he().boundaryField()[inlet] + 0.5*magSqr(U.boundaryField()[inlet]) ) ) <<" [W]" << endl; Info<< "rho max/avg/min : " << gMax(thermo.rho()) << " " << gAverage(thermo.rho()) << " " << gMin(thermo.rho()) << endl; Info<< "T max/avg/min : " << gMax(thermo.T()) << " " << gAverage(thermo.T()) << " " << gMin(thermo.T()) << endl; Info<< "P max/avg/min : " << gMax(thermo.p()) << " " << gAverage(thermo.p()) << " " << gMin(thermo.p()) << endl; Info<< "Prg max/avg/min : " << gMax(p_rgh) << " " << gAverage(p_rgh) << " " << gMin(p_rgh) << endl; Info<< "U max/avg/min : " << gMax(U).component(2) << " " << gAverage(U).component(2) << " " << gMin(U).component(2) << endl; Info<< "Prg max-min : " << gMax(p_rgh) - gMin(p_rgh) << endl; Info<< " " << endl; } Info<< "End\n" << endl; return 0; }
void Foam::fv::radialActuationDiskSource:: addRadialActuationDiskAxialInertialResistance ( vectorField& Usource, const labelList& cells, const scalarField& Vcells, const RhoFieldType& rho, const vectorField& U ) const { scalar a = 1.0 - Cp_/Ct_; scalarField Tr(cells.size()); const vector uniDiskDir = diskDir_/mag(diskDir_); tensor E(Zero); E.xx() = uniDiskDir.x(); E.yy() = uniDiskDir.y(); E.zz() = uniDiskDir.z(); const Field<vector> zoneCellCentres(mesh().cellCentres(), cells); const Field<scalar> zoneCellVolumes(mesh().cellVolumes(), cells); const vector avgCentre = gSum(zoneCellVolumes*zoneCellCentres)/V(); const scalar maxR = gMax(mag(zoneCellCentres - avgCentre)); scalar intCoeffs = radialCoeffs_[0] + radialCoeffs_[1]*sqr(maxR)/2.0 + radialCoeffs_[2]*pow4(maxR)/3.0; vector upU = vector(VGREAT, VGREAT, VGREAT); scalar upRho = VGREAT; if (upstreamCellId_ != -1) { upU = U[upstreamCellId_]; upRho = rho[upstreamCellId_]; } reduce(upU, minOp<vector>()); reduce(upRho, minOp<scalar>()); scalar T = 2.0*upRho*diskArea_*mag(upU)*a*(1.0 - a); forAll(cells, i) { scalar r2 = magSqr(mesh().cellCentres()[cells[i]] - avgCentre); Tr[i] = T *(radialCoeffs_[0] + radialCoeffs_[1]*r2 + radialCoeffs_[2]*sqr(r2)) /intCoeffs; Usource[cells[i]] += ((Vcells[cells[i]]/V_)*Tr[i]*E) & upU; }
void calcIncompressibleYPlus ( const fvMesh& mesh, const Time& runTime, const volVectorField& U, volScalarField& yPlus ) { typedef incompressible::RASModels::nutWallFunctionFvPatchScalarField wallFunctionPatchField; #include "createPhi.H" singlePhaseTransportModel laminarTransport(U, phi); autoPtr<incompressible::RASModel> RASModel ( incompressible::RASModel::New(U, phi, laminarTransport) ); const volScalarField::GeometricBoundaryField nutPatches = RASModel->nut()().boundaryField(); bool foundNutPatch = false; forAll(nutPatches, patchi) { if (isA<wallFunctionPatchField>(nutPatches[patchi])) { foundNutPatch = true; const wallFunctionPatchField& nutPw = dynamic_cast<const wallFunctionPatchField&> (nutPatches[patchi]); yPlus.boundaryField()[patchi] = nutPw.yPlus(); const scalarField& Yp = yPlus.boundaryField()[patchi]; Info<< "Patch " << patchi << " named " << nutPw.patch().name() << " y+ : min: " << gMin(Yp) << " max: " << gMax(Yp) << " average: " << gAverage(Yp) << nl << endl; } } if (!foundNutPatch) { Info<< " no " << wallFunctionPatchField::typeName << " patches" << endl; } }
void kinematicSingleLayer::info() { Info<< "\nSurface film: " << type() << endl; const scalarField& deltaInternal = delta_; const vectorField& Uinternal = U_; scalar addedMassTotal = 0.0; outputProperties().readIfPresent("addedMassTotal", addedMassTotal); addedMassTotal += returnReduce(addedMassTotal_, sumOp<scalar>()); Info<< indent << "added mass = " << addedMassTotal << nl << indent << "current mass = " << gSum((deltaRho_*magSf())()) << nl << indent << "min/max(mag(U)) = " << gMin(mag(Uinternal)) << ", " << gMax(mag(Uinternal)) << nl << indent << "min/max(delta) = " << gMin(deltaInternal) << ", " << gMax(deltaInternal) << nl << indent << "coverage = " << gSum(alpha_.primitiveField()*magSf())/gSum(magSf()) << nl; injection_.info(Info); transfer_.info(Info); }
bool Foam::functionObjects::yPlus::write(const bool postProcess) { const volScalarField& yPlus = obr_.lookupObject<volScalarField>(type()); Log << type() << " " << name() << " write:" << nl << " writing field " << yPlus.name() << endl; yPlus.write(); writeFiles::write(); const volScalarField::Boundary& yPlusBf = yPlus.boundaryField(); const fvMesh& mesh = refCast<const fvMesh>(obr_); const fvPatchList& patches = mesh.boundary(); forAll(patches, patchi) { const fvPatch& patch = patches[patchi]; if (isA<wallFvPatch>(patch)) { const scalarField& yPlusp = yPlusBf[patchi]; const scalar minYplus = gMin(yPlusp); const scalar maxYplus = gMax(yPlusp); const scalar avgYplus = gAverage(yPlusp); if (Pstream::master()) { Log << " patch " << patch.name() << " y+ : min = " << minYplus << ", max = " << maxYplus << ", average = " << avgYplus << nl; writeTime(file()); file() << token::TAB << patch.name() << token::TAB << minYplus << token::TAB << maxYplus << token::TAB << avgYplus << endl; } } } return true; }
bool Foam::functionObjects::yPlus::write() { Log << type() << " " << name() << " write:" << nl; writeLocalObjects::write(); logFiles::write(); const volScalarField& yPlus = mesh_.lookupObject<volScalarField>(type()); const volScalarField::Boundary& yPlusBf = yPlus.boundaryField(); const fvPatchList& patches = mesh_.boundary(); forAll(patches, patchi) { const fvPatch& patch = patches[patchi]; if (isA<wallFvPatch>(patch)) { const scalarField& yPlusp = yPlusBf[patchi]; const scalar minYplus = gMin(yPlusp); const scalar maxYplus = gMax(yPlusp); const scalar avgYplus = gAverage(yPlusp); if (Pstream::master()) { Log << " patch " << patch.name() << " y+ : min = " << minYplus << ", max = " << maxYplus << ", average = " << avgYplus << nl; writeTime(file()); file() << token::TAB << patch.name() << token::TAB << minYplus << token::TAB << maxYplus << token::TAB << avgYplus << endl; } } } Log << endl; return true; }
void writeData( CommonValueExpressionDriver &driver, const wordList &accumulations ) { bool isPoint=driver.result().isPoint(); Field<T> result(driver.getResult<T>(isPoint)); forAll(accumulations,i) { const word &aName=accumulations[i]; const NumericAccumulationNamedEnum::value accu= NumericAccumulationNamedEnum::names[aName]; T val=pTraits<T>::zero; switch(accu) { case NumericAccumulationNamedEnum::numMin: val=gMin(result); break; case NumericAccumulationNamedEnum::numMax: val=gMax(result); break; case NumericAccumulationNamedEnum::numSum: val=gSum(result); break; case NumericAccumulationNamedEnum::numAverage: val=gAverage(result); break; // case NumericAccumulationNamedEnum::numSumMag: // val=gSumMag(result); // break; case NumericAccumulationNamedEnum::numWeightedAverage: val=driver.calcWeightedAverage(result); break; default: WarningIn("funkyDoCalc") << "Unimplemented accumultation type " << NumericAccumulationNamedEnum::names[accu] << ". Currently only 'min', 'max', 'sum', 'weightedAverage' and 'average' are supported" << endl; } Info << " " << aName << "=" << val; } }
tmp<volScalarField> rampingRadiation::Shs() { tmp<volScalarField> tShs ( new volScalarField ( IOobject ( typeName + "_Shs", owner().time().timeName(), owner().regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), owner().regionMesh(), dimensionedScalar("zero", dimMass/pow3(dimTime), 0.0), zeroGradientFvPatchScalarField::typeName ) ); const scalar time = owner().time().value(); if ((time >= timeStart_) && (time <= timeStart_ + duration_)) { if(time > rampStartTime_ + rampTimeInterval_ ){ QrConst_.internalField() += rampStep_; rampStartTime_ += rampTimeInterval_; Info << "time, QrConst = " << time << ", " << gMax(QrConst_) << endl; } scalarField& Shs = tShs(); const scalarField& Qr = QrConst_.internalField(); // const scalarField& alpha = owner_.alpha().internalField(); // Shs = mask_*Qr*alpha*absorptivity_; Shs = mask_*Qr*absorptivity_; // Qin_ is used in turbulentTemperatureRadiationCoupledMixedST // boundary condition Qin_.internalField() = mask_*Qr; Qin_.correctBoundaryConditions(); } return tShs; }
void swakExpressionFunctionObject::writeData(CommonValueExpressionDriver &driver) { Field<T> result=driver.getResult<T>(); Field<T> results(accumulations_.size()); forAll(accumulations_,i) { const word &aName=accumulations_[i]; T val=pTraits<T>::zero; if(aName=="min") { val=gMin(result); } else if(aName=="max") { val=gMax(result); } else if(aName=="sum") { val=gSum(result); } else if(aName=="average") { val=gAverage(result); } else { WarningIn("swakExpressionFunctionObject::writeData") << "Unknown accumultation type " << aName << ". Currently only 'min', 'max', 'sum' and 'average' are supported" << endl; } results[i]=val; if(verbose()) { Info << " " << aName << "=" << val; } } if (Pstream::master()) { unsigned int w = IOstream::defaultPrecision() + 7; OFstream& o=*filePtrs_[name()]; o << setw(w) << time().value(); forAll(results,i) { o << setw(w) << results[i]; } o << nl; }
void Foam::radiation::greyDiffusiveViewFactorFixedValueFvPatchScalarField:: updateCoeffs() { //Do nothing if (debug) { scalar Q = gSum((*this)*patch().magSf()); Info<< patch().boundaryMesh().mesh().name() << ':' << patch().name() << ':' << this->dimensionedInternalField().name() << " <- " << " heat[W]:" << Q << " wall radiative heat flux " << " min:" << gMin(*this) << " max:" << gMax(*this) << " avg:" << gAverage(*this) << endl; } }
void Foam::mappedFieldFvPatchField<Type>::updateCoeffs() { if (this->updated()) { return; } this->operator==(this->mappedField()); if (debug) { Info<< "operating on field:" << this->dimensionedInternalField().name() << " patch:" << this->patch().name() << " avg:" << gAverage(*this) << " min:" << gMin(*this) << " max:" << gMax(*this) << endl; } fixedValueFvPatchField<Type>::updateCoeffs(); }
void printIntegrate ( const fvMesh& mesh, const IOobject& fieldHeader, bool& done ) { if (!done && fieldHeader.headerClassName() == FieldType::typeName) { Info<< " Reading " << fieldHeader.headerClassName() << " " << fieldHeader.name() << " "; FieldType field(fieldHeader, mesh); Info<< field.dimensions() << endl; Info<< " min : " << gMin(field) << nl << " max : " << gMax(field) << nl; done = true; } }
void Foam::calcTypes::mag::writeMagField ( const IOobject& header, const fvMesh& mesh, bool& processed ) { typedef GeometricField<Type, fvPatchField, volMesh> fieldType; if (header.headerClassName() == fieldType::typeName) { Info<< " Reading " << header.name() << endl; fieldType field(header, mesh); Info<< " Calculating mag" << header.name() << endl; volScalarField magField ( IOobject ( "mag" + header.name(), mesh.time().timeName(), mesh, IOobject::NO_READ ), Foam::mag(field) ); Info << "mag(" << header.name() << "): max: " << gMax(magField.internalField()) << " min: " << gMin(magField.internalField()) << endl; magField.write(); processed = true; } }
Foam::scalar Foam::compressibleCourantNo ( const fvMesh& mesh, const Time& runTime, const volScalarField& rho, const surfaceScalarField& phi ) { scalarField sumPhi ( fvc::surfaceSum(mag(phi))().primitiveField() / rho.primitiveField() ); scalar CoNum = 0.5*gMax(sumPhi/mesh.V().field())*runTime.deltaTValue(); scalar meanCoNum = 0.5*(gSum(sumPhi)/gSum(mesh.V().field()))*runTime.deltaTValue(); Info<< "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum << " max: " << CoNum << endl; return CoNum; }
int main(int argc, char *argv[]) { # include "setRootCase.H" # include "createTime.H" # include "createMesh.H" # include "createFields.H" # include "createHistory.H" # include "readDivSigmaExpMethod.H" # include "createSolidInterfaceNoModify.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while(runTime.loop()) { Info<< "Time: " << runTime.timeName() << nl << endl; # include "readSolidMechanicsControls.H" int iCorr = 0; lduMatrix::solverPerformance solverPerf; scalar initialResidual = 1.0; scalar relativeResidual = 1.0; lduMatrix::debug = 0; if (predictor) { Info<< "\nPredicting U, gradU and snGradU based on V," << "gradV and snGradV\n" << endl; U += V*runTime.deltaT(); gradU += gradV*runTime.deltaT(); snGradU += snGradV*runTime.deltaT(); } do { U.storePrevIter(); # include "calculateDivSigmaExp.H" // linear momentum equation fvVectorMatrix UEqn ( rho*fvm::d2dt2(U) == fvm::laplacian(2*muf + lambdaf, U, "laplacian(DU,U)") + divSigmaExp ); if (solidInterfaceCorr) { solidInterfacePtr->correct(UEqn); } solverPerf = UEqn.solve(); if (iCorr == 0) { initialResidual = solverPerf.initialResidual(); aitkenInitialRes = gMax(mag(U.internalField())); } if (aitkenRelax) { # include "aitkenRelaxation.H" } else { U.relax(); } gradU = fvc::grad(U); # include "calculateRelativeResidual.H" if (iCorr % infoFrequency == 0) { Info<< "\tTime " << runTime.value() << ", Corrector " << iCorr << ", Solving for " << U.name() << " using " << solverPerf.solverName() << ", res = " << solverPerf.initialResidual() << ", rel res = " << relativeResidual; if (aitkenRelax) { Info<< ", aitken = " << aitkenTheta; } Info<< ", inner iters = " << solverPerf.nIterations() << endl; } } while ( iCorr++ == 0 || ( solverPerf.initialResidual() > convergenceTolerance //relativeResidual > convergenceTolerance && iCorr < nCorr ) ); Info<< nl << "Time " << runTime.value() << ", Solving for " << U.name() << ", Initial residual = " << initialResidual << ", Final residual = " << solverPerf.initialResidual() << ", Relative residual = " << relativeResidual << ", No outer iterations " << iCorr << nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << endl; if (predictor) { V = fvc::ddt(U); gradV = fvc::ddt(gradU); snGradV = (snGradU - snGradU.oldTime())/runTime.deltaT(); } # include "calculateEpsilonSigma.H" # include "writeFields.H" # include "writeHistory.H" Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" << endl; } Info<< "End\n" << endl; return(0); }
void thermalBaffle1DFvPatchScalarField<solidType>::updateCoeffs() { if (updated()) { return; } // Since we're inside initEvaluate/evaluate there might be processor // comms underway. Change the tag we use. int oldTag = UPstream::msgType(); UPstream::msgType() = oldTag+1; const mapDistribute& mapDist = this->mappedPatchBase::map(); const label patchi = patch().index(); const label nbrPatchi = samplePolyPatch().index(); if (baffleActivated_) { const fvPatch& nbrPatch = patch().boundaryMesh()[nbrPatchi]; const compressible::turbulenceModel& turbModel = db().template lookupObject<compressible::turbulenceModel> ( "turbulenceModel" ); // local properties const scalarField kappaw(turbModel.kappaEff(patchi)); const fvPatchScalarField& Tp = patch().template lookupPatchField<volScalarField, scalar>(TName_); scalarField Qr(Tp.size(), 0.0); if (QrName_ != "none") { Qr = patch().template lookupPatchField<volScalarField, scalar> (QrName_); Qr = QrRelaxation_*Qr + (1.0 - QrRelaxation_)*QrPrevious_; QrPrevious_ = Qr; } tmp<scalarField> Ti = patchInternalField(); scalarField myKDelta(patch().deltaCoeffs()*kappaw); // nrb properties scalarField nbrTp = turbModel.thermo().T().boundaryField()[nbrPatchi]; mapDist.distribute(nbrTp); // solid properties scalarField kappas(patch().size(), 0.0); forAll(kappas, i) { kappas[i] = solid().kappa(0.0, (Tp[i] + nbrTp[i])/2.0); } const scalarField KDeltaSolid(kappas/baffleThickness()); const scalarField alpha(KDeltaSolid - Qr/Tp); valueFraction() = alpha/(alpha + myKDelta); refValue() = (KDeltaSolid*nbrTp + Qs()/2.0)/alpha; if (debug) { scalar Q = gAverage(kappaw*snGrad()); Info<< patch().boundaryMesh().mesh().name() << ':' << patch().name() << ':' << this->dimensionedInternalField().name() << " <- " << nbrPatch.name() << ':' << this->dimensionedInternalField().name() << " :" << " heat[W]:" << Q << " walltemperature " << " min:" << gMin(*this) << " max:" << gMax(*this) << " avg:" << gAverage(*this) << endl; } }
void Foam::timeVaryingMappedFixedValuePointPatchField<Type>::updateCoeffs() { if (this->updated()) { return; } checkTable(); // Interpolate between the sampled data Type wantedAverage; if (endSampleTime_ == -1) { // only start value if (debug) { Pout<< "updateCoeffs : Sampled, non-interpolated values" << " from start time:" << sampleTimes_[startSampleTime_].name() << nl; } this->operator==(startSampledValues_); wantedAverage = startAverage_; } else { scalar start = sampleTimes_[startSampleTime_].value(); scalar end = sampleTimes_[endSampleTime_].value(); scalar s = (this->db().time().value()-start)/(end-start); if (debug) { Pout<< "updateCoeffs : Sampled, interpolated values" << " between start time:" << sampleTimes_[startSampleTime_].name() << " and end time:" << sampleTimes_[endSampleTime_].name() << " with weight:" << s << endl; } this->operator==((1-s)*startSampledValues_ + s*endSampledValues_); wantedAverage = (1-s)*startAverage_ + s*endAverage_; } // Enforce average. Either by scaling (if scaling factor > 0.5) or by // offsetting. if (setAverage_) { const Field<Type>& fld = *this; Type averagePsi = gAverage(fld); if (debug) { Pout<< "updateCoeffs :" << " actual average:" << averagePsi << " wanted average:" << wantedAverage << endl; } if (mag(averagePsi) < VSMALL) { // Field too small to scale. Offset instead. const Type offset = wantedAverage - averagePsi; if (debug) { Pout<< "updateCoeffs :" << " offsetting with:" << offset << endl; } this->operator==(fld+offset); } else { const scalar scale = mag(wantedAverage)/mag(averagePsi); if (debug) { Pout<< "updateCoeffs :" << " scaling with:" << scale << endl; } this->operator==(scale*fld); } } // apply offset to mapped values if (offset_.valid()) { const scalar t = this->db().time().timeOutputValue(); this->operator==(*this + offset_->value(t)); } if (debug) { Pout<< "updateCoeffs : set fixedValue to min:" << gMin(*this) << " max:" << gMax(*this) << " avg:" << gAverage(*this) << endl; } fixedValuePointPatchField<Type>::updateCoeffs(); }
void turbulentTemperatureCoupledBaffleMixedFvPatchScalarField::updateCoeffs() { if (updated()) { return; } // Since we're inside initEvaluate/evaluate there might be processor // comms underway. Change the tag we use. int oldTag = UPstream::msgType(); UPstream::msgType() = oldTag+1; // Get the coupling information from the mappedPatchBase const mappedPatchBase& mpp = refCast<const mappedPatchBase>(patch().patch()); const polyMesh& nbrMesh = mpp.sampleMesh(); const label samplePatchi = mpp.samplePolyPatch().index(); const fvPatch& nbrPatch = refCast<const fvMesh>(nbrMesh).boundary()[samplePatchi]; // Calculate the temperature by harmonic averaging // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ const turbulentTemperatureCoupledBaffleMixedFvPatchScalarField& nbrField = refCast < const turbulentTemperatureCoupledBaffleMixedFvPatchScalarField > ( nbrPatch.lookupPatchField<volScalarField, scalar> ( TnbrName_ ) ); // Swap to obtain full local values of neighbour internal field tmp<scalarField> nbrIntFld(new scalarField(nbrField.size(), 0.0)); tmp<scalarField> nbrKDelta(new scalarField(nbrField.size(), 0.0)); if (contactRes_ == 0.0) { nbrIntFld.ref() = nbrField.patchInternalField(); nbrKDelta.ref() = nbrField.kappa(nbrField)*nbrPatch.deltaCoeffs(); } else { nbrIntFld.ref() = nbrField; nbrKDelta.ref() = contactRes_; } mpp.distribute(nbrIntFld.ref()); mpp.distribute(nbrKDelta.ref()); tmp<scalarField> myKDelta = kappa(*this)*patch().deltaCoeffs(); // Both sides agree on // - temperature : (myKDelta*fld + nbrKDelta*nbrFld)/(myKDelta+nbrKDelta) // - 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 = zero gradient // - refValue = neighbour value // - mixFraction = nbrKDelta / (nbrKDelta + myKDelta()) this->refValue() = nbrIntFld(); this->refGrad() = 0.0; this->valueFraction() = nbrKDelta()/(nbrKDelta() + myKDelta()); mixedFvPatchScalarField::updateCoeffs(); if (debug) { scalar Q = gSum(kappa(*this)*patch().magSf()*snGrad()); Info<< patch().boundaryMesh().mesh().name() << ':' << patch().name() << ':' << this->internalField().name() << " <- " << nbrMesh.name() << ':' << nbrPatch.name() << ':' << this->internalField().name() << " :" << " heat transfer rate:" << Q << " walltemperature " << " min:" << gMin(*this) << " max:" << gMax(*this) << " avg:" << gAverage(*this) << endl; } // Restore tag UPstream::msgType() = oldTag; }