void Foam::radiation::absorptionEmissionModel::correct
(
volScalarField& a,
PtrList<volScalarField>& aj
) const
{
a.internalField() = this->a();
aj[0].internalField() = a.internalField();
}
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());
}
}
tmp<GeometricField<Type, fvPatchField, volMesh> >
EulerLocalDdtScheme<Type>::fvcDdt
(
const volScalarField& rho,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
const objectRegistry& registry = this->mesh();
// get access to the scalar beta[i]
const scalarField& beta =
registry.lookupObject<scalarField>(deltaTName_);
volScalarField rDeltaT =
1.0/(beta[0]*registry.lookupObject<volScalarField>(deltaTauName_));
IOobject ddtIOobject
(
"ddt("+rho.name()+','+vf.name()+')',
mesh().time().timeName(),
mesh()
);
if (mesh().moving())
{
return tmp<GeometricField<Type, fvPatchField, volMesh> >
(
new GeometricField<Type, fvPatchField, volMesh>
(
ddtIOobject,
mesh(),
rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
rDeltaT.internalField()*
(
rho.internalField()*vf.internalField()
- rho.oldTime().internalField()
*vf.oldTime().internalField()*mesh().V0()/mesh().V()
),
rDeltaT.boundaryField()*
(
rho.boundaryField()*vf.boundaryField()
- rho.oldTime().boundaryField()
*vf.oldTime().boundaryField()
)
)
);
}
else
{
return tmp<GeometricField<Type, fvPatchField, volMesh> >
(
new GeometricField<Type, fvPatchField, volMesh>
(
ddtIOobject,
rDeltaT*(rho*vf - rho.oldTime()*vf.oldTime())
)
);
}
}
Foam::tmp<Foam::volVectorField>
Foam::fv::faceLimitedGrad<Foam::scalar>::calcGrad
(
const volScalarField& vsf,
const word& name
) const
{
const fvMesh& mesh = vsf.mesh();
tmp<volVectorField> tGrad = basicGradScheme_().calcGrad(vsf, name);
if (k_ < SMALL)
{
return tGrad;
}
volVectorField& g = tGrad();
const labelUList& owner = mesh.owner();
const labelUList& neighbour = mesh.neighbour();
const volVectorField& C = mesh.C();
const surfaceVectorField& Cf = mesh.Cf();
// create limiter
scalarField limiter(vsf.internalField().size(), 1.0);
scalar rk = (1.0/k_ - 1.0);
forAll(owner, facei)
{
label own = owner[facei];
label nei = neighbour[facei];
scalar vsfOwn = vsf[own];
scalar vsfNei = vsf[nei];
scalar maxFace = max(vsfOwn, vsfNei);
scalar minFace = min(vsfOwn, vsfNei);
scalar maxMinFace = rk*(maxFace - minFace);
maxFace += maxMinFace;
minFace -= maxMinFace;
// owner side
limitFace
(
limiter[own],
maxFace - vsfOwn, minFace - vsfOwn,
(Cf[facei] - C[own]) & g[own]
);
// neighbour side
limitFace
(
limiter[nei],
maxFace - vsfNei, minFace - vsfNei,
(Cf[facei] - C[nei]) & g[nei]
);
}
void makeGraph
(
const scalarField& x,
const volScalarField& vsf,
const word& name,
const word& graphFormat
)
{
makeGraph(x, vsf.internalField(), name, vsf.path(), graphFormat);
}
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());
}
}
void Foam::fv::limitTemperature::correct(volScalarField& he)
{
const basicThermo& thermo =
mesh_.lookupObject<basicThermo>(basicThermo::dictName);
scalarField Tmin(cells_.size(), Tmin_);
scalarField Tmax(cells_.size(), Tmax_);
scalarField heMin(thermo.he(thermo.p(), Tmin, cells_));
scalarField heMax(thermo.he(thermo.p(), Tmax, cells_));
scalarField& hec = he.internalField();
forAll(cells_, i)
{
label cellI = cells_[i];
hec[cellI]= max(min(hec[cellI], heMax[i]), heMin[i]);
}
tmp<fvMatrix<Type> >
EulerLocalDdtScheme<Type>::fvmDdt
(
const volScalarField& rho,
GeometricField<Type, fvPatchField, volMesh>& vf
)
{
const objectRegistry& registry = this->mesh();
// get access to the scalar beta[i]
const scalarField& beta =
registry.lookupObject<scalarField>(deltaTName_);
tmp<fvMatrix<Type> > tfvm
(
new fvMatrix<Type>
(
vf,
rho.dimensions()*vf.dimensions()*dimVol/dimTime
)
);
fvMatrix<Type>& fvm = tfvm();
scalarField rDeltaT =
1.0/(beta[0]*registry.lookupObject<volScalarField>(deltaTauName_).internalField());
fvm.diag() = rDeltaT*rho.internalField()*mesh().V();
if (mesh().moving())
{
fvm.source() = rDeltaT
*rho.oldTime().internalField()
*vf.oldTime().internalField()*mesh().V0();
}
else
{
fvm.source() = rDeltaT
*rho.oldTime().internalField()
*vf.oldTime().internalField()*mesh().V();
}
return tfvm;
}
void makeGraph
(
const scalarField& x,
const volScalarField& vsf,
const word& name,
const word& graphFormat
)
{
fileName path(vsf.rootPath()/vsf.caseName()/"graphs"/vsf.instance());
mkDir(path);
makeGraph
(
x,
vsf.internalField(),
name,
path,
graphFormat
);
}
Foam::tmp<Foam::volVectorField>
Foam::fv::cellLimitedGrad<Foam::scalar>::calcGrad
(
const volScalarField& vsf,
const word& name
) const
{
const fvMesh& mesh = vsf.mesh();
tmp<volVectorField> tGrad = basicGradScheme_().calcGrad(vsf, name);
if (k_ < SMALL)
{
return tGrad;
}
volVectorField& g = tGrad();
const labelUList& owner = mesh.owner();
const labelUList& neighbour = mesh.neighbour();
const volVectorField& C = mesh.C();
const surfaceVectorField& Cf = mesh.Cf();
scalarField maxVsf(vsf.internalField());
scalarField minVsf(vsf.internalField());
forAll(owner, facei)
{
label own = owner[facei];
label nei = neighbour[facei];
scalar vsfOwn = vsf[own];
scalar vsfNei = vsf[nei];
maxVsf[own] = max(maxVsf[own], vsfNei);
minVsf[own] = min(minVsf[own], vsfNei);
maxVsf[nei] = max(maxVsf[nei], vsfOwn);
minVsf[nei] = min(minVsf[nei], vsfOwn);
}
void phaseChangeModel::correct
(
const scalar dt,
scalarField& availableMass,
volScalarField& dMass,
volScalarField& dEnergy
)
{
correctModel
(
dt,
availableMass,
dMass,
dEnergy
);
latestMassPC_ = sum(dMass.internalField());
totalMassPC_ += latestMassPC_;
availableMass -= dMass;
dMass.correctBoundaryConditions();
}
tmp<volVectorField> cellMDLimitedGrad<scalar>::grad
(
const volScalarField& vsf
) const
{
const fvMesh& mesh = vsf.mesh();
tmp<volVectorField> tGrad = basicGradScheme_().grad(vsf);
if (k_ < SMALL)
{
return tGrad;
}
volVectorField& g = tGrad();
const unallocLabelList& owner = mesh.owner();
const unallocLabelList& neighbour = mesh.neighbour();
const volVectorField& C = mesh.C();
const surfaceVectorField& Cf = mesh.Cf();
scalarField maxVsf(vsf.internalField());
scalarField minVsf(vsf.internalField());
forAll(owner, facei)
{
label own = owner[facei];
label nei = neighbour[facei];
scalar vsfOwn = vsf[own];
scalar vsfNei = vsf[nei];
maxVsf[own] = max(maxVsf[own], vsfNei);
minVsf[own] = min(minVsf[own], vsfNei);
maxVsf[nei] = max(maxVsf[nei], vsfOwn);
minVsf[nei] = min(minVsf[nei], vsfOwn);
}
void Foam::MULES::implicitSolve
(
const RhoType& rho,
volScalarField& psi,
const surfaceScalarField& phi,
surfaceScalarField& phiPsi,
const SpType& Sp,
const SuType& Su,
const scalar psiMax,
const scalar psiMin
)
{
const fvMesh& mesh = psi.mesh();
const dictionary& MULEScontrols = mesh.solverDict(psi.name());
label maxIter
(
readLabel(MULEScontrols.lookup("maxIter"))
);
label nLimiterIter
(
readLabel(MULEScontrols.lookup("nLimiterIter"))
);
scalar maxUnboundedness
(
readScalar(MULEScontrols.lookup("maxUnboundedness"))
);
scalar CoCoeff
(
readScalar(MULEScontrols.lookup("CoCoeff"))
);
scalarField allCoLambda(mesh.nFaces());
{
tmp<surfaceScalarField> Cof =
mesh.time().deltaT()*mesh.surfaceInterpolation::deltaCoeffs()
*mag(phi)/mesh.magSf();
slicedSurfaceScalarField CoLambda
(
IOobject
(
"CoLambda",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh,
dimless,
allCoLambda,
false // Use slices for the couples
);
CoLambda == 1.0/max(CoCoeff*Cof, scalar(1));
}
scalarField allLambda(allCoLambda);
//scalarField allLambda(mesh.nFaces(), 1.0);
slicedSurfaceScalarField lambda
(
IOobject
(
"lambda",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh,
dimless,
allLambda,
false // Use slices for the couples
);
linear<scalar> CDs(mesh);
upwind<scalar> UDs(mesh, phi);
//fv::uncorrectedSnGrad<scalar> snGrads(mesh);
fvScalarMatrix psiConvectionDiffusion
(
fvm::ddt(rho, psi)
+ fv::gaussConvectionScheme<scalar>(mesh, phi, UDs).fvmDiv(phi, psi)
//- fv::gaussLaplacianScheme<scalar, scalar>(mesh, CDs, snGrads)
//.fvmLaplacian(Dpsif, psi)
- fvm::Sp(Sp, psi)
- Su
);
surfaceScalarField phiBD(psiConvectionDiffusion.flux());
surfaceScalarField& phiCorr = phiPsi;
phiCorr -= phiBD;
for (label i=0; i<maxIter; i++)
{
if (i != 0 && i < 4)
{
allLambda = allCoLambda;
}
limiter
(
allLambda,
rho,
psi,
phiBD,
phiCorr,
Sp,
Su,
psiMax,
psiMin,
nLimiterIter
);
solve
(
psiConvectionDiffusion + fvc::div(lambda*phiCorr),
MULEScontrols
);
scalar maxPsiM1 = gMax(psi.internalField()) - 1.0;
scalar minPsi = gMin(psi.internalField());
scalar unboundedness = max(max(maxPsiM1, 0.0), -min(minPsi, 0.0));
if (unboundedness < maxUnboundedness)
{
break;
}
else
{
Info<< "MULES: max(" << psi.name() << " - 1) = " << maxPsiM1
<< " min(" << psi.name() << ") = " << minPsi << endl;
phiBD = psiConvectionDiffusion.flux();
/*
word gammaScheme("div(phi,gamma)");
word gammarScheme("div(phirb,gamma)");
const surfaceScalarField& phir =
mesh.lookupObject<surfaceScalarField>("phir");
phiCorr =
fvc::flux
(
phi,
psi,
gammaScheme
)
+ fvc::flux
(
-fvc::flux(-phir, scalar(1) - psi, gammarScheme),
psi,
gammarScheme
)
- phiBD;
*/
}
}
phiPsi = psiConvectionDiffusion.flux() + lambda*phiCorr;
}
void Foam::fv::interRegionExplicitPorositySource::addSup
(
const volScalarField& rho,
fvMatrix<vector>& eqn,
const label fieldI
)
{
initialise();
const fvMesh& nbrMesh = mesh_.time().lookupObject<fvMesh>(nbrRegionName_);
const volVectorField& U = eqn.psi();
volVectorField UNbr
(
IOobject
(
name_ + ":UNbr",
nbrMesh.time().timeName(),
nbrMesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
nbrMesh,
dimensionedVector("zero", U.dimensions(), vector::zero)
);
// map local velocity onto neighbour region
meshInterp().mapSrcToTgt
(
U.internalField(),
plusEqOp<vector>(),
UNbr.internalField()
);
fvMatrix<vector> nbrEqn(UNbr, eqn.dimensions());
volScalarField rhoNbr
(
IOobject
(
"rho:UNbr",
nbrMesh.time().timeName(),
nbrMesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
nbrMesh,
dimensionedScalar("zero", dimDensity, 0.0)
);
volScalarField muNbr
(
IOobject
(
"mu:UNbr",
nbrMesh.time().timeName(),
nbrMesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
nbrMesh,
dimensionedScalar("zero", dimViscosity, 0.0)
);
const volScalarField& mu =
mesh_.lookupObject<volScalarField>(muName_);
// map local rho onto neighbour region
meshInterp().mapSrcToTgt
(
rho.internalField(),
plusEqOp<scalar>(),
rhoNbr.internalField()
);
// map local mu onto neighbour region
meshInterp().mapSrcToTgt
(
mu.internalField(),
plusEqOp<scalar>(),
muNbr.internalField()
);
porosityPtr_->addResistance(nbrEqn, rhoNbr, muNbr);
// convert source from neighbour to local region
fvMatrix<vector> porosityEqn(U, eqn.dimensions());
scalarField& Udiag = porosityEqn.diag();
vectorField& Usource = porosityEqn.source();
Udiag.setSize(eqn.diag().size(), 0.0);
Usource.setSize(eqn.source().size(), vector::zero);
meshInterp().mapTgtToSrc(nbrEqn.diag(), plusEqOp<scalar>(), Udiag);
meshInterp().mapTgtToSrc(nbrEqn.source(), plusEqOp<vector>(), Usource);
eqn -= porosityEqn;
}
// solve vegetation model
void modifiedVegetationModel::solve(volVectorField& U, volScalarField& T, volScalarField& w)
{
// solve radiation within vegetation
radiation();
const double p_ = 101325;
// Magnitude of velocity
volScalarField magU("magU", mag(U));
// Bounding velocity
bound(magU, UMin_);
// solve aerodynamic, stomatal resistance
volScalarField new_Tl("new_Tl", Tl_);
// info
Info << " max leaf temp tl=" << max(T.internalField())
<< "k, iteration i=0" << endl;
scalar maxError, maxRelError;
int i;
// solve leaf temperature, iteratively.
int maxIter = 500;
for (i=1; i<=maxIter; i++)
{
// Solve aerodynamc, stomatal resistance
resistance(magU, T, w, new_Tl);
forAll(LAD_, cellI)
{
if (LAD_[cellI] > 10*SMALL)
{
// Initial leaf temperature
if (i==1)
Tl_[cellI];// = T[cellI];//*0. + 300.;//T[cellI];
// Calculate saturated density, specific humidity
rhosat_[cellI] = calc_rhosat(Tl_[cellI]);
evsat_[cellI] = calc_evsat(Tl_[cellI]);
wsat_[cellI] = 0.621945*(evsat_[cellI]/(p_-evsat_[cellI])); // ASHRAE 1, eq.23
// Calculate transpiration rate]);
E_[cellI] = nEvapSides_.value()*LAD_[cellI]*rhoa_.value()*(wsat_[cellI]-w[cellI])/(ra_[cellI]+rs_[cellI]);
//E_[cellI] = 0.0; // No evapotranspiration
// Calculate latent heat flux
Ql_[cellI] = lambda_.value()*E_[cellI];
// Calculate new leaf temperature
new_Tl[cellI] = T[cellI] + (Rn_[cellI] - Ql_[cellI])*(ra_[cellI]/(2.0*rhoa_.value()*cpa_.value()*LAD_[cellI]));
}
}
// info
Info << " max leaf temp tl=" << gMax(new_Tl.internalField())
<< " K, iteration i=" << i << endl;
// Check rel. L-infinity error
maxError = gMax(mag(new_Tl.internalField()-Tl_.internalField()));
maxRelError = maxError/gMax(mag(new_Tl.internalField()));
// update leaf temp.
forAll(Tl_, cellI)
Tl_[cellI] = 0.5*Tl_[cellI]+0.5*new_Tl[cellI];
// convergence check
if (maxRelError < 1e-8)
break;
}
Tl_.correctBoundaryConditions();
// Iteration info
Info << "Vegetation model: Solving for Tl, Final residual = " << maxError
<< ", Final relative residual = " << maxRelError
<< ", No Iterations " << i << endl;
Info << "temperature parameters: max Tl = " << gMax(Tl_)
<< ", min T = " << gMin(T) << ", max T = " << gMax(T) << endl;
Info << "resistances: max rs = " << gMax(rs_)
<< ", max ra = " << gMax(ra_) << endl;
// Final: Solve aerodynamc, stomatal resistance
resistance(magU, T, w, Tl_);
// Final: Update sensible and latent heat flux
forAll(LAD_, cellI)
{
if (LAD_[cellI] > 10*SMALL)
{
// Calculate saturated density, specific humidity
rhosat_[cellI] = calc_rhosat(Tl_[cellI]);
evsat_[cellI] = calc_evsat(Tl_[cellI]);
wsat_[cellI] = 0.621945*(evsat_[cellI]/(p_-evsat_[cellI])); // ASHRAE 1, eq.23
// Calculate transpiration rate
E_[cellI] = nEvapSides_.value()*LAD_[cellI]*rhoa_.value()*(wsat_[cellI]-w[cellI])/(ra_[cellI]+rs_[cellI]); // todo: implement switch for double or single side
// Calculate latent heat flux
Ql_[cellI] = lambda_.value()*E_[cellI];
// Calculate sensible heat flux
Qs_[cellI] = 2.0*rhoa_.value()*cpa_.value()*LAD_[cellI]*(Tl_[cellI]-T[cellI])/ra_[cellI];
}
}
rhosat_.correctBoundaryConditions();
wsat_.correctBoundaryConditions();
E_.correctBoundaryConditions();
Ql_.correctBoundaryConditions();
Qs_.correctBoundaryConditions();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
void scalarGeneralExchange::manipulateScalarField(volScalarField& explicitEulerSource,
volScalarField& implicitEulerSource,
int speciesID) const
{
// reset Scalar field
explicitEulerSource.internalField() = 0.0;
implicitEulerSource.internalField() = 0.0;
if(speciesID>=0 && particleSpeciesValue_[speciesID]<0.0) //skip if species is not active
return;
//Set the names of the exchange fields
word fieldName;
word partDatName;
word partFluxName;
word partTransCoeffName;
word partFluidName;
scalar transportParameter;
// realloc the arrays to pull particle data
if(speciesID<0) //this is the temperature - always pull from LIGGGHTS
{
fieldName = tempFieldName_;
partDatName = partTempName_;
partFluxName = partHeatFluxName_;
partTransCoeffName = partHeatTransCoeffName_;
partFluidName = partHeatFluidName_;
transportParameter = lambda_;
allocateMyArrays(0.0);
particleCloud_.dataExchangeM().getData(partDatName,"scalar-atom", partDat_);
}
else
{
fieldName = eulerianFieldNames_[speciesID];
partDatName = partSpeciesNames_[speciesID];
partFluxName = partSpeciesFluxNames_[speciesID];
partTransCoeffName = partSpeciesTransCoeffNames_[speciesID];
partFluidName = partSpeciesFluidNames_[speciesID];
transportParameter = DMolecular_[speciesID];
allocateMyArrays(0.0);
if(particleSpeciesValue_[speciesID]>ALARGECONCENTRATION)
particleCloud_.dataExchangeM().getData(partDatName,"scalar-atom", partDat_);
}
if (scaleDia_ > 1)
Info << typeName << " using scale = " << scaleDia_ << endl;
else if (particleCloud_.cg() > 1)
{
scaleDia_=particleCloud_.cg();
Info << typeName << " using scale from liggghts cg = " << scaleDia_ << endl;
}
//==============================
// get references
const volScalarField& voidfraction_(particleCloud_.mesh().lookupObject<volScalarField> (voidfractionFieldName_)); // ref to voidfraction field
const volVectorField& U_(particleCloud_.mesh().lookupObject<volVectorField> (velFieldName_));
const volScalarField& fluidScalarField_(particleCloud_.mesh().lookupObject<volScalarField> (fieldName)); // ref to scalar field
const volScalarField& nufField = forceSubM(0).nuField();
//==============================
// calc La based heat flux
vector position(0,0,0);
scalar voidfraction(1);
vector Ufluid(0,0,0);
scalar fluidValue(0);
label cellI=0;
vector Us(0,0,0);
vector Ur(0,0,0);
scalar dscaled(0);
scalar nuf(0);
scalar magUr(0);
scalar As(0);
scalar Rep(0);
scalar Pr(0);
scalar sDth(scaleDia_*scaleDia_*scaleDia_);
interpolationCellPoint<scalar> voidfractionInterpolator_(voidfraction_);
interpolationCellPoint<vector> UInterpolator_(U_);
interpolationCellPoint<scalar> fluidScalarFieldInterpolator_(fluidScalarField_);
#include "setupProbeModel.H"
for(int index = 0;index < particleCloud_.numberOfParticles(); ++index)
{
cellI = particleCloud_.cellIDs()[index][0];
if(cellI >= 0)
{
if(forceSubM(0).interpolation())
{
position = particleCloud_.position(index);
voidfraction = voidfractionInterpolator_.interpolate(position,cellI);
Ufluid = UInterpolator_.interpolate(position,cellI);
fluidValue = fluidScalarFieldInterpolator_.interpolate(position,cellI);
}else
{
voidfraction = voidfraction_[cellI];
Ufluid = U_[cellI];
fluidValue = fluidScalarField_[cellI];
}
// calc relative velocity
Us = particleCloud_.velocity(index);
Ur = Ufluid-Us;
magUr = mag(Ur);
dscaled = 2*particleCloud_.radius(index)/scaleDia_;
As = dscaled*dscaled*M_PI*sDth;
nuf = nufField[cellI];
Rep = dscaled*magUr/nuf;
if(speciesID<0) //have temperature
Pr = Prandtl_;
else
Pr = max(SMALL,nuf/transportParameter); //This is Sc for species
scalar alpha = transportParameter*(this->*Nusselt)(Rep,Pr,voidfraction)/(dscaled);
// calc convective heat flux [W]
scalar areaTimesTransferCoefficient = alpha * As;
scalar tmpPartFlux = areaTimesTransferCoefficient
* (fluidValue - partDat_[index][0]);
partDatFlux_[index][0] = tmpPartFlux;
// split implicit/explicit contribution
forceSubM(0).explicitCorrScalar( partDatTmpImpl_[index][0],
partDatTmpExpl_[index][0],
areaTimesTransferCoefficient,
fluidValue,
fluidScalarField_[cellI],
partDat_[index][0],
forceSubM(0).verbose()
);
if(validPartTransCoeff_)
partDatTransCoeff_[index][0] = alpha;
if(validPartFluid_)
partDatFluid_[index][0] = fluidValue;
if( forceSubM(0).verbose())
{
Pout << "fieldName = " << fieldName << endl;
Pout << "partTransCoeffName = " << partTransCoeffName << endl;
Pout << "index = " <<index << endl;
Pout << "partFlux = " << tmpPartFlux << endl;
Pout << "magUr = " << magUr << endl;
Pout << "As = " << As << endl;
Pout << "r = " << particleCloud_.radius(index) << endl;
Pout << "dscaled = " << dscaled << endl;
Pout << "nuf = " << nuf << endl;
Pout << "Rep = " << Rep << endl;
Pout << "Pr/Sc = " << Pr << endl;
Pout << "Nup/Shp = " << (this->*Nusselt)(Rep,Pr,voidfraction) << endl;
Pout << "partDatTransCoeff: " << partDatTransCoeff_[index][0] << endl;
Pout << "voidfraction = " << voidfraction << endl;
Pout << "partDat_[index][0] = " << partDat_[index][0] << endl ;
Pout << "fluidValue = " << fluidValue << endl ;
}
//Set value fields and write the probe
if(probeIt_)
{
#include "setupProbeModelfields.H"
vValues.append(Ur);
sValues.append((this->*Nusselt)(Rep,Pr,voidfraction));
sValues.append(Rep);
particleCloud_.probeM().writeProbe(index, sValues, vValues);
}
}
}
//Handle explicit and implicit source terms on the Euler side
//these are simple summations!
particleCloud_.averagingM().setScalarSum
(
explicitEulerSource,
partDatTmpExpl_,
particleCloud_.particleWeights(),
NULL
);
particleCloud_.averagingM().setScalarSum
(
implicitEulerSource,
partDatTmpImpl_,
particleCloud_.particleWeights(),
NULL
);
// scale with the cell volume to get (total) volume-specific source
explicitEulerSource.internalField() /= -explicitEulerSource.mesh().V();
implicitEulerSource.internalField() /= -implicitEulerSource.mesh().V();
// limit explicit source term
scalar explicitEulerSourceInCell;
forAll(explicitEulerSource,cellI)
{
explicitEulerSourceInCell = explicitEulerSource[cellI];
if(mag(explicitEulerSourceInCell) > maxSource_ )
{
explicitEulerSource[cellI] = sign(explicitEulerSourceInCell) * maxSource_;
}
}
