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);
}
