void Foam::outletMappedUniformInletFvPatchField<Type>::updateCoeffs() { if (this->updated()) { return; } const GeometricField<Type, fvPatchField, volMesh>& f ( dynamic_cast<const GeometricField<Type, fvPatchField, volMesh>&> ( this->dimensionedInternalField() ) ); const fvPatch& p = this->patch(); label outletPatchID = p.patch().boundaryMesh().findPatchID(outletPatchName_); if (outletPatchID < 0) { FatalErrorIn ( "void outletMappedUniformInletFvPatchField<Type>::updateCoeffs()" ) << "Unable to find outlet patch " << outletPatchName_ << abort(FatalError); } const fvPatch& outletPatch = p.boundaryMesh()[outletPatchID]; const fvPatchField<Type>& outletPatchField = f.boundaryField()[outletPatchID]; const surfaceScalarField& phi = this->db().objectRegistry::template lookupObject<surfaceScalarField> (phiName_); const scalarField& outletPatchPhi = phi.boundaryField()[outletPatchID]; scalar sumOutletPatchPhi = gSum(outletPatchPhi); if (sumOutletPatchPhi > SMALL) { Type averageOutletField = gSum(outletPatchPhi*outletPatchField) /sumOutletPatchPhi; this->operator==(averageOutletField); } else { Type averageOutletField = gSum(outletPatch.magSf()*outletPatchField) /gSum(outletPatch.magSf()); this->operator==(averageOutletField); } fixedValueFvPatchField<Type>::updateCoeffs(); }
void fixedMeanFvPatchField<Type>::updateCoeffs() { if (this->updated()) { return; } gpuField<Type> newValues(this->patchInternalField()); Type meanValuePsi = gSum(this->patch().magSf()*newValues) /gSum(this->patch().magSf()); if (mag(meanValue_) > SMALL && mag(meanValuePsi)/mag(meanValue_) > 0.5) { newValues *= mag(meanValue_)/mag(meanValuePsi); } else { newValues += (meanValue_ - meanValuePsi); } this->operator==(newValues); fixedValueFvPatchField<Type>::updateCoeffs(); }
Foam::swirlFlowRateInletVelocityFvPatchVectorField:: swirlFlowRateInletVelocityFvPatchVectorField ( const fvPatch& p, const DimensionedField<vector, volMesh>& iF, const dictionary& dict ) : fixedValueFvPatchField<vector>(p, iF, dict), phiName_(dict.lookupOrDefault<word>("phi", "phi")), rhoName_(dict.lookupOrDefault<word>("rho", "rho")), origin_ ( dict.lookupOrDefault ( "origin", returnReduce(patch().size(), maxOp<label>()) ? gSum(patch().Cf()*patch().magSf())/gSum(patch().magSf()) : Zero ) ), axis_ ( dict.lookupOrDefault ( "axis", returnReduce(patch().size(), maxOp<label>()) ? -gSum(patch().Sf())/gSum(patch().magSf()) : Zero ) ), flowRate_(Function1<scalar>::New("flowRate", dict)), rpm_(Function1<scalar>::New("rpm", dict)) {}
typename Foam::BlockSolverPerformance<Type> Foam::BlockAmgSolver<Type>::solve ( Field<Type>& x, const Field<Type>& b ) { // Prepare solver performance BlockSolverPerformance<Type> solverPerf ( typeName, this->fieldName() ); scalar norm = this->normFactor(x, b); // Calculate initial residual solverPerf.initialResidual() = gSum(cmptMag(amg_.residual(x, b)))/norm; solverPerf.finalResidual() = solverPerf.initialResidual(); if (!this->stop(solverPerf)) { do { amg_.cycle(x, b); solverPerf.finalResidual() = gSum(cmptMag(amg_.residual(x, b)))/norm; solverPerf.nIterations()++; } while (!this->stop(solverPerf)); } return solverPerf; }
void pressureInletUniformVelocityFvPatchVectorField::operator= ( const fvPatchField<vector>& pvf ) { operator==(patch().nf()*gSum(patch().Sf() & pvf)/gSum(patch().magSf())); }
int main(int argc, char *argv[]) { timeSelector::addOptions(); argList::validArgs.append("patchName"); #include "setRootCase.H" #include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); const word vecFieldName = "wallShearStress"; #include "createMesh.H" runTime.setTime(timeDirs.last(), timeDirs.size()-1); const word patchName = args[1]; forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; Info << " Read vector field " << vecFieldName << endl; IOobject vecFieldHeader ( vecFieldName, runTime.timeName(), mesh, IOobject::MUST_READ, IOobject::NO_WRITE ); if (!vecFieldHeader.headerOk()) { Info << "Unable to read vector field" << vecFieldName << endl; return EXIT_FAILURE; } const label patchI = mesh.boundaryMesh().findPatchID(patchName); if (patchI < 0) { FatalError << "Unable to find patch " << patchName << nl << exit(FatalError); } const volVectorField vectorField(vecFieldHeader, mesh); const scalarField magVecField = magSqr(vectorField.boundaryField()[patchI]); const scalar area = gSum(mesh.magSf().boundaryField()[patchI]); scalar meanSqr = gSum(magVecField * mesh.magSf().boundaryField()[patchI]) / area; Info << " RMS(mag(" << vecFieldName << ")) = " << Foam::sqrt(meanSqr) << endl; Info << " max(mag(" << vecFieldName << ")) = " << Foam::sqrt(Foam::gMax(magVecField)); Info << endl; }
void Foam::swirlFlowRateInletVelocityFvPatchVectorField::updateCoeffs() { if (updated()) { return; } const scalar t = this->db().time().timeOutputValue(); const scalar flowRate = flowRate_->value(t); const scalar rpm = rpm_->value(t); const scalar totArea = gSum(patch().magSf()); const scalar avgU = -flowRate/totArea; const vector avgCenter = gSum(patch().Cf()*patch().magSf())/totArea; const vector avgNormal = gSum(patch().Sf())/totArea; // Update angular velocity - convert [rpm] to [rad/s] tmp<vectorField> tangentialVelocity ( (rpm*constant::mathematical::pi/30.0) * (patch().Cf() - avgCenter) ^ avgNormal ); tmp<vectorField> n = patch().nf(); const surfaceScalarField& phi = db().lookupObject<surfaceScalarField>(phiName_); if (phi.dimensions() == dimVelocity*dimArea) { // volumetric flow-rate operator==(tangentialVelocity + n*avgU); } else if (phi.dimensions() == dimDensity*dimVelocity*dimArea) { const fvPatchField<scalar>& rhop = patch().lookupPatchField<volScalarField, scalar>(rhoName_); // mass flow-rate operator==(tangentialVelocity + n*avgU/rhop); } else { FatalErrorIn ( "swirlFlowRateInletVelocityFvPatchVectorField::updateCoeffs()" ) << "dimensions of " << phiName_ << " are incorrect" << nl << " on patch " << this->patch().name() << " of field " << this->dimensionedInternalField().name() << " in file " << this->dimensionedInternalField().objectPath() << nl << exit(FatalError); } fixedValueFvPatchField<vector>::updateCoeffs(); }
typename Foam::BlockSolverPerformance<Type> Foam::BlockGaussSeidelSolver<Type>::solve ( Field<Type>& x, const Field<Type>& b ) { // Create local references to avoid the spread this-> ugliness const BlockLduMatrix<Type>& matrix = this->matrix_; // Prepare solver performance BlockSolverPerformance<Type> solverPerf ( typeName, this->fieldName() ); scalar norm = this->normFactor(x, b); Field<Type> wA(x.size()); // Calculate residual. Note: sign of residual swapped for efficiency matrix.Amul(wA, x); wA -= b; solverPerf.initialResidual() = gSum(cmptMag(wA))/norm; solverPerf.finalResidual() = solverPerf.initialResidual(); // Check convergence, solve if not converged if (!this->stop(solverPerf)) { // Iteration loop do { for (label i = 0; i < nSweeps_; i++) { gs_.precondition(x, b); solverPerf.nIterations()++; } // Re-calculate residual. Note: sign of residual swapped // for efficiency matrix.Amul(wA, x); wA -= b; solverPerf.finalResidual() = gSum(cmptMag(wA))/norm; solverPerf.nIterations()++; } while (!this->stop(solverPerf)); } return solverPerf; }
void pressureInletUniformVelocityFvPatchVectorField::updateCoeffs() { if (updated()) { return; } pressureInletVelocityFvPatchVectorField::updateCoeffs(); operator==(patch().nf()*gSum(patch().Sf() & *this)/gSum(patch().magSf())); }
dimensioned<Type> DimensionedField<Type, GeoMesh>::weightedAverage ( const DimensionedField<scalar, GeoMesh>& weightField ) const { return ( dimensioned<Type> ( this->name() + ".weightedAverage(weights)", this->dimensions(), gSum(weightField*field())/gSum(weightField) ) ); }
void Foam::fanPressureFvPatchScalarField::updateCoeffs() { if (updated()) { return; } // Retrieve flux field const surfaceScalarField& phi = db().lookupObject<surfaceScalarField>(phiName()); const fvsPatchField<scalar>& phip = patch().patchField<surfaceScalarField, scalar>(phi); int dir = 2*direction_ - 1; // Average volumetric flow rate scalar volFlowRate = 0; if (phi.dimensions() == dimVelocity*dimArea) { volFlowRate = dir*gSum(phip); } else if (phi.dimensions() == dimVelocity*dimArea*dimDensity) { const scalarField& rhop = patch().lookupPatchField<volScalarField, scalar>(rhoName()); volFlowRate = dir*gSum(phip/rhop); } else { FatalErrorInFunction << "dimensions of phi are not correct" << "\n on patch " << patch().name() << " of field " << internalField().name() << " in file " << internalField().objectPath() << nl << exit(FatalError); } // Pressure drop for this flow rate const scalar pdFan = fanCurve_(max(volFlowRate, 0.0)); totalPressureFvPatchScalarField::updateCoeffs ( p0() - dir*pdFan, patch().lookupPatchField<volVectorField, vector>(UName()) ); }
void Foam::fieldValues::cellSource::initialise(const dictionary& dict) { setCellZoneCells(); if (nCells_ == 0) { WarningIn ( "Foam::fieldValues::cellSource::initialise(const dictionary&)" ) << type() << " " << name_ << ": " << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl << " Source has no cells - deactivating" << endl; active_ = false; return; } Info<< type() << " " << name_ << ":" << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl << " total cells = " << nCells_ << nl << " total volume = " << gSum(filterField(mesh().V())) << nl << endl; if (operation_ == opWeightedAverage) { dict.lookup("weightField") >> weightFieldName_; Info<< " weight field = " << weightFieldName_; }
Foam::scalar Foam::lduMatrix::solver::normFactor ( const scalarField& x, const scalarField& b, const scalarField& Ax, scalarField& tmpField, const direction cmpt ) const { // Calculate A dot reference value of x // matrix_.sumA(tmpField, coupleBouCoeffs_, interfaces_); // tmpField *= gAverage(x); // Calculate normalisation factor using full multiplication // with mean value. HJ, 5/Nov/2007 scalar xRef = gAverage(x); matrix_.Amul ( tmpField, scalarField(x.size(), xRef), coupleBouCoeffs_, interfaces_, cmpt ); return gSum(mag(Ax - tmpField) + mag(b - tmpField)) + matrix_.small_; // At convergence this simpler method is equivalent to the above // return 2*gSumMag(b) + matrix_.small_; }
void Foam::flowRateInletVelocityFvPatchVectorField::updateCoeffs ( const scalar uniformRho ) { if (updated()) { return; } const scalar t = db().time().timeOutputValue(); // a simpler way of doing this would be nice const scalar avgU = -flowRate_->value(t)/gSum(patch().magSf()); tmp<vectorField> n = patch().nf(); if (volumetric_ || rhoName_ == "none") { // volumetric flow-rate operator==(n*avgU); } else { // mass flow-rate operator==(n*avgU/uniformRho); } }
void Foam::fieldValues::cellSource::write() { fieldValue::write(); if (active_) { scalar totalVolume = gSum(filterField(mesh().V())); if (Pstream::master()) { file() << obr_.time().value() << tab << totalVolume; } forAll(fields_, i) { writeValues<scalar>(fields_[i]); writeValues<vector>(fields_[i]); writeValues<sphericalTensor>(fields_[i]); writeValues<symmTensor>(fields_[i]); writeValues<tensor>(fields_[i]); } if (Pstream::master()) { file()<< endl; } if (log_) { Info<< endl; } }
void Foam::fieldValues::cellSource::initialise(const dictionary& dict) { setCellZoneCells(); Info<< type() << " " << name_ << ":" << nl << " total cells = " << nCells_ << nl << " total volume = " << gSum(filterField(mesh().V())) << nl << endl; if (operation_ == opWeightedAverage) { dict.lookup("weightField") >> weightFieldName_; if ( obr().foundObject<volScalarField>(weightFieldName_) ) { Info<< " weight field = " << weightFieldName_; } else { FatalErrorIn("cellSource::initialise()") << type() << " " << name_ << ": " << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl << " Weight field " << weightFieldName_ << " must be a " << volScalarField::typeName << nl << exit(FatalError); } }
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::calc(const argList& args, const Time& runTime, const fvMesh& mesh) { Info<< "\tdomain volume = " << gSum(mesh.V()) << endl; const cellZoneMesh& cellZones = mesh.cellZones(); scalar cellZoneVolTotal(0); if (cellZones.size()) { Info << "cellZones:" << endl; forAll(cellZones, i) { const cellZone& zone = mesh.cellZones()[i]; const cellZoneMesh& zoneMesh = zone.zoneMesh(); const labelList& cellsZone = zoneMesh[i]; scalar cellZoneVol(0); //float cellZoneVol=0.0; forAll(cellsZone, cI) { cellZoneVol += mesh.V()[cellsZone[cI]]; } Info << '\t' << zone.name() << " volume = " << cellZoneVol << endl; cellZoneVolTotal += cellZoneVol; } }
void printSum ( const fvMesh& mesh, const IOobject& fieldHeader, const label patchI, bool& done ) { if (!done && fieldHeader.headerClassName() == FieldType::typeName) { Info<< " Reading " << FieldType::typeName << " " << fieldHeader.name() << endl; FieldType field(fieldHeader, mesh); typename FieldType::value_type sumField = gSum ( field.boundaryField()[patchI] ); Info<< " Integral of " << fieldHeader.name() << " over patch " << mesh.boundary()[patchI].name() << '[' << patchI << ']' << " = " << sumField << nl; done = true; } }
int main(int argc, char *argv[]) { timeSelector::addOptions(); #include "addRegionOption.H" argList::validArgs.append("fieldName"); #include "setRootCase.H" #include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); #include "createNamedMesh.H" const word fieldName = args[1]; forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; IOobject fieldHeader ( fieldName, runTime.timeName(), mesh, IOobject::MUST_READ ); // Check field exists if (fieldHeader.headerOk()) { mesh.readUpdate(); // Give fluid volume Info<< " Volume of fluid = " << gSum(mesh.V()) << " [m3]" << endl; // Read field and calc integral bool done = false; printIntegrate<volScalarField>(mesh,fieldHeader,done); printIntegrate<volVectorField>(mesh,fieldHeader,done); printIntegrate<volSphericalTensorField>(mesh,fieldHeader,done); printIntegrate<volSymmTensorField>(mesh,fieldHeader,done); printIntegrate<volTensorField>(mesh,fieldHeader,done); if (!done) { FatalError << "Only possible to integrate volFields." << " Field " << fieldName << " is of type " << fieldHeader.headerClassName() << nl << exit(FatalError); } } else { Info<< " No field " << fieldName << endl; } Info<< endl; }
void Foam::swirlFlowRateInletVelocityFvPatchVectorField::updateCoeffs() { if (updated()) { return; } const scalar totArea = gSum(patch().magSf()); if (totArea > ROOTVSMALL && axis_ != vector(Zero)) { const scalar t = this->db().time().timeOutputValue(); const scalar flowRate = flowRate_->value(t); const scalar omega = rpmToRads(rpm_->value(t)); const scalar avgU = -flowRate/totArea; const vector axisHat = axis_/mag(axis_); // Update angular velocity tmp<vectorField> tangentialVelocity ( axisHat ^ omega*(patch().Cf() - origin_) ); tmp<vectorField> n = patch().nf(); const surfaceScalarField& phi = db().lookupObject<surfaceScalarField>(phiName_); if (phi.dimensions() == dimVelocity*dimArea) { // volumetric flow-rate operator==(tangentialVelocity + n*avgU); } else if (phi.dimensions() == dimDensity*dimVelocity*dimArea) { const fvPatchField<scalar>& rhop = patch().lookupPatchField<volScalarField, scalar>(rhoName_); // mass flow-rate operator==(tangentialVelocity + n*avgU/rhop); } else { FatalErrorInFunction << "dimensions of " << phiName_ << " are incorrect" << nl << " on patch " << this->patch().name() << " of field " << this->internalField().name() << " in file " << this->internalField().objectPath() << nl << exit(FatalError); } } fixedValueFvPatchField<vector>::updateCoeffs(); }
dimensioned<Type> domainIntegrate ( const DimensionedField<Type, volMesh>& df ) { return dimensioned<Type> ( "domainIntegrate(" + df.name() + ')', dimVol*df.dimensions(), gSum(fvc::volumeIntegrate(df)) ); }
int get(int v, int ll, int rr, int l, int r, int y1, int y2) { if (rr <= l || r <= ll) return 0; if (l <= ll && rr <= r) { int * a = rn[v]; int * f = fn[v]; int hi = bse(a, cn[v], y2); int lo = bse(a, cn[v], y1); return gSum(f, lo, hi); } int mid = (ll + rr) >> 1; return get(v + v, ll, mid, l, r, y1, y2) + get(v + v + 1, mid, rr, l, r, y1, y2); }
typename Foam::BlockSolverPerformance<Type> Foam::BlockGMRESSolver<Type>::solve ( Field<Type>& x, const Field<Type>& b ) { // Create local references to avoid the spread this-> ugliness const BlockLduMatrix<Type>& matrix = this->matrix_; // Prepare solver performance BlockSolverPerformance<Type> solverPerf ( typeName, this->fieldName() ); scalar norm = this->normFactor(x, b); // Multiplication helper typename BlockCoeff<Type>::multiply mult; Field<Type> wA(x.size()); // Calculate initial residual matrix.Amul(wA, x); Field<Type> rA(b - wA); solverPerf.initialResidual() = gSum(cmptMag(rA))/norm; solverPerf.finalResidual() = solverPerf.initialResidual(); // Check convergence, solve if not converged if (!solverPerf.checkConvergence(this->tolerance(), this->relTolerance())) { // Create the Hesenberg matrix scalarSquareMatrix H(nDirs_, 0); // Create y and b for Hessenberg matrix scalarField yh(nDirs_, 0); scalarField bh(nDirs_ + 1, 0); // Givens rotation vectors scalarField c(nDirs_, 0); scalarField s(nDirs_, 0); // Allocate Krylov space vectors FieldField<Field, Type> V(nDirs_ + 1); forAll (V, i) { V.set(i, new Field<Type>(x.size(), pTraits<Type>::zero)); }
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; }
dimensioned<Type> domainIntegrate ( const GeometricField<Type, fvPatchField, volMesh>& vf ) { return dimensioned<Type> ( "domainIntegrate(" + vf.name() + ')', dimVol*vf.dimensions(), gSum(fvc::volumeIntegrate(vf)) ); }
void printIntegrate ( const fvMesh& mesh, const IOobject& fieldHeader, const label patchI, bool& done ) { if (!done && fieldHeader.headerClassName() == FieldType::typeName) { Info<< " Reading " << fieldHeader.headerClassName() << " " << fieldHeader.name() << endl; FieldType field(fieldHeader, mesh); Info<< " Integral of " << fieldHeader.name() << " over vector area of patch " << mesh.boundary()[patchI].name() << '[' << patchI << ']' << " = " << gSum ( mesh.Sf().boundaryField()[patchI] *field.boundaryField()[patchI] ) << nl; Info<< " Integral of " << fieldHeader.name() << " over area magnitude of patch " << mesh.boundary()[patchI].name() << '[' << patchI << ']' << " = " << gSum ( mesh.magSf().boundaryField()[patchI] *field.boundaryField()[patchI] ) << nl; done = true; } }
void Foam::flowRateInletVelocityFvPatchVectorField::updateCoeffs() { if (updated()) { return; } const scalar t = db().time().timeOutputValue(); // a simpler way of doing this would be nice const scalar avgU = -flowRate_->value(t)/gSum(patch().magSf()); tmp<vectorField> n = patch().nf(); if (volumetric_ || rhoName_ == "none") { // volumetric flow-rate or density not given operator==(n*avgU); } else { // mass flow-rate if ( patch().boundaryMesh().mesh().foundObject<volScalarField>(rhoName_) ) { const fvPatchField<scalar>& rhop = patch().lookupPatchField<volScalarField, scalar>(rhoName_); operator==(n*avgU/rhop); } else { // Use constant density if (rhoInlet_ < 0) { FatalErrorIn ( "flowRateInletVelocityFvPatchVectorField::updateCoeffs()" ) << "Did not find registered density field " << rhoName_ << " and no constant density 'rhoInlet' specified" << exit(FatalError); } operator==(n*avgU/rhoInlet_); } } fixedValueFvPatchField<vector>::updateCoeffs(); }
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); }