Foam::S_MDCPP::S_MDCPP
(
const word& name,
const volVectorField& U,
const surfaceScalarField& phi,
const dictionary& dict
)
:
viscoelasticLaw(name, U, phi),
tau_
(
IOobject
(
"tau" + name,
U.time().timeName(),
U.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
U.mesh()
),
I_
(
dimensionedSymmTensor
(
"I",
dimensionSet(0, 0, 0, 0, 0, 0, 0),
symmTensor
(
1, 0, 0,
1, 0,
1
)
)
),
rho_(dict.lookup("rho")),
etaS_(dict.lookup("etaS")),
etaP_(dict.lookup("etaP")),
zeta_(dict.lookup("zeta")),
lambdaOb_(dict.lookup("lambdaOb")),
lambdaOs_(dict.lookup("lambdaOs")),
q_(dict.lookup("q"))
{}
continuousGasKEpsilon<BasicTurbulenceModel>::continuousGasKEpsilon
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
kEpsilon<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName,
type
),
liquidTurbulencePtr_(NULL),
nutEff_
(
IOobject
(
IOobject::groupName("nutEff", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
this->nut_
),
alphaInversion_
(
dimensioned<scalar>::lookupOrAddToDict
(
"alphaInversion",
this->coeffDict_,
0.7
)
)
{
if (type == typeName)
{
kEpsilon<BasicTurbulenceModel>::correctNut();
this->printCoeffs(type);
}
}
Foam::autoPtr<Foam::SRF::SRFModel> Foam::SRF::SRFModel::New
(
const volVectorField& Urel
)
{
// get model name, but do not register the dictionary
// otherwise it is registered in the database twice
const word modelType
(
IOdictionary
(
IOobject
(
"SRFProperties",
Urel.time().constant(),
Urel.db(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
).lookup("SRFModel")
);
Info<< "Selecting SRFModel " << modelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(modelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"SRFModel::New(const fvMesh&)"
) << "Unknown SRFModel type "
<< modelType << nl << nl
<< "Valid SRFModel types are :" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
return autoPtr<SRFModel>(cstrIter()(Urel));
}
Foam::scalar Foam::fv::patchMeanVelocityForce::magUbarAve
(
const volVectorField& U
) const
{
vector2D sumAmagUsumA
(
sum
(
(flowDir_ & U.boundaryField()[patchi_])
*mesh_.boundary()[patchi_].magSf()
),
sum(mesh_.boundary()[patchi_].magSf())
);
// If the mean velocity force is applied to a cyclic patch
// for parallel runs include contributions from processorCyclic patches
// generated from the decomposition of the cyclic patch
const polyBoundaryMesh& patches = mesh_.boundaryMesh();
if (Pstream::parRun() && isA<cyclicPolyPatch>(patches[patchi_]))
{
labelList processorCyclicPatches
(
processorCyclicPolyPatch::patchIDs(patch_, patches)
);
forAll(processorCyclicPatches, pcpi)
{
const label patchi = processorCyclicPatches[pcpi];
sumAmagUsumA.x() +=
sum
(
(flowDir_ & U.boundaryField()[patchi])
*mesh_.boundary()[patchi].magSf()
);
sumAmagUsumA.y() += sum(mesh_.boundary()[patchi].magSf());
}
}
viscoelasticModel::viscoelasticModel
(
const volScalarField& alpha,
const volVectorField& U,
const surfaceScalarField& phi
)
:
IOdictionary
(
IOobject
(
"viscoelasticProperties",
U.time().constant(),
U.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
lawPtr_(viscoelasticLaw::New(word::null, alpha, U, phi, subDict("rheology")))
{}
wallModel::wallModel
(
const dictionary& dict,
const volVectorField& U,
spray& sm
)
:
dict_(dict),
mesh_(U.mesh()),
spray_(sm)
{}
void dilute::setVectorAverage
(
volVectorField& field,
double**& value,
double**& weight,
volScalarField& weightField,
double**const& mask,
double**const& weight2, //allows the specification of a 2nd weight field
bool weightWithWeight2 //switch to activate 2nd weight field
) const
{
label cellI;
vector valueVec;
scalar weightP;
if(weightWithWeight2) //use weight2, e.g., mass-averaged - has no effect, just weight is DIFFERENT!
for(int index=0; index< particleCloud_.numberOfParticles(); index++)
{
for(int subCell=0;subCell<particleCloud_.cellsPerParticle()[index][0];subCell++)
{
cellI = particleCloud_.cellIDs()[index][subCell];
if (cellI >= 0)
{
for(int i=0;i<3;i++) valueVec[i] = value[index][i];
weightP = weight[index][subCell]*weight2[index][subCell];
weightField[cellI] += weightP;
if(weightP > 0) field[cellI] = valueVec; //field[cellI] = valueVec/weightP;
}
}
}
else //standard, i.e., volume-averaged - has no effect, just weight is DIFFERENT!
for(int index=0; index< particleCloud_.numberOfParticles(); index++)
{
for(int subCell=0;subCell<particleCloud_.cellsPerParticle()[index][0];subCell++)
{
//Info << "subCell=" << subCell << endl;
cellI = particleCloud_.cellIDs()[index][subCell];
if (cellI >= 0)
{
for(int i=0;i<3;i++) valueVec[i] = value[index][i];
weightP = weight[index][subCell];
weightField[cellI] += weightP;
if(weightP > 0) field[cellI] = valueVec; //field[cellI] = valueVec/weightP;
else Warning << "!!! W A R N I N G --- weightP <= 0" << endl;
}
}
}
// correct cell values to patches
field.correctBoundaryConditions();
}
scaleSimilarity::scaleSimilarity
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport
)
:
LESModel(typeName, U, phi, transport),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
printCoeffs();
}
LESModel::LESModel
(
const word& type,
const volScalarField& rho,
const volVectorField& U,
const surfaceScalarField& phi,
const basicThermo& thermoPhysicalModel,
const word& turbulenceModelName
)
:
turbulenceModel(rho, U, phi, thermoPhysicalModel, turbulenceModelName),
IOdictionary
(
IOobject
(
"LESProperties",
U.time().constant(),
U.db(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
),
printCoeffs_(lookupOrDefault<Switch>("printCoeffs", false)),
coeffDict_(subOrEmptyDict(type + "Coeffs")),
kMin_("kMin", sqr(dimVelocity), SMALL),
delta_(LESdelta::New("delta", U.mesh(), *this))
{
kMin_.readIfPresent(*this);
// Force the construction of the mesh deltaCoeffs which may be needed
// for the construction of the derived models and BCs
mesh_.deltaCoeffs();
}
void Foam::twoStrokeEngine::setBoundaryVelocity(volVectorField& U)
{
vector pistonVel = piston().cs().axis()*engTime().pistonSpeed().value();
// On the piston movingWallVelocity is used.
// There is no need to update the piston velocity
forAll (scavInPortPatches_, patchi)
{
const label curPatchID =
boundaryMesh().findPatchID(scavInPortPatches_[patchi]);
U.boundaryField()[curPatchID] == pistonVel;
}
}
void Foam::porosityModels::powerLaw::calcForce
(
const volVectorField& U,
const volScalarField& rho,
const volScalarField& mu,
vectorField& force
) const
{
scalarField Udiag(U.size(), 0.0);
const scalarField& V = mesh_.V();
apply(Udiag, V, rho, U);
force = Udiag*U;
}
dynOneEqEddy::dynOneEqEddy
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport,
const word& turbulenceModelName,
const word& modelName
)
:
LESModel(modelName, U, phi, transport, turbulenceModelName),
GenEddyVisc(U, phi, transport),
k_
(
IOobject
(
"k",
runTime_.timeName(),
mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh_
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
bound(k_, kMin_);
const volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
updateSubGridScaleFields(symm(fvc::grad(U)), KK);
printCoeffs();
}
graph calcEk
(
const volVectorField& U,
const Kmesh& K
)
{
return kShellIntegration
(
fft::forwardTransform
(
ReComplexField(U.internalField()),
K.nn()
),
K
);
}
void dense::setVectorAverage
(
volVectorField& field,
double**& value,
double**& weight,
volScalarField& weightField,
double**const& mask
) const
{
label cellI;
vector valueVec;
scalar weightP;
for(int index=0; index< particleCloud_.numberOfParticles(); index++)
{
if(mask[index][0])
{
for(int subCell=0;subCell<particleCloud_.voidFractionM().cellsPerParticle()[index][0];subCell++)
{
cellI = particleCloud_.cellIDs()[index][subCell];
if (cellI >= 0)
{
for(int i=0;i<3;i++) valueVec[i] = value[index][i];
weightP = weight[index][subCell];
// first entry in this cell
if(weightField[cellI] == 0)
{
field[cellI] = valueVec;
weightField[cellI] = weightP;
}
else
{
field[cellI] = (field[cellI]*weightField[cellI]+valueVec*weightP)/(weightField[cellI]+weightP);
weightField[cellI] += weightP;
}
}
}//forAllSubPoints
}
}
// correct cell values to patches
field.correctBoundaryConditions();
}
dynOneEqEddy::dynOneEqEddy
(
const volScalarField& rho,
const volVectorField& U,
const surfaceScalarField& phi,
const basicThermo& thermoPhysicalModel
)
:
LESModel(typeName, rho, U, phi, thermoPhysicalModel),
GenEddyVisc(rho, U, phi, thermoPhysicalModel),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
updateSubGridScaleFields(dev(symm(fvc::grad(U))));
printCoeffs();
}
Foam::nonlinearEddyViscosity<BasicTurbulenceModel>::nonlinearEddyViscosity
(
const word& modelName,
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName
)
:
eddyViscosity<BasicTurbulenceModel>
(
modelName,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
nonlinearStress_
(
IOobject
(
IOobject::groupName("nonlinearStress", U.group()),
this->runTime_.timeName(),
this->mesh_
),
this->mesh_,
dimensionedSymmTensor
(
"nonlinearStress",
sqr(dimVelocity),
symmTensor::zero
)
)
{}
void Foam::porosityModels::solidification::apply
(
tensorField& AU,
const RhoFieldType& rho,
const volVectorField& U
) const
{
if (alphaName_ == "none")
{
return apply(AU, geometricOneField(), rho, U);
}
else
{
const volScalarField& alpha = mesh_.lookupObject<volScalarField>
(
IOobject::groupName(alphaName_, U.group())
);
return apply(AU, alpha, rho, U);
}
}
Foam::mixtureViscosityModels::slurry::slurry
(
const word& name,
const dictionary& viscosityProperties,
const volVectorField& U,
const surfaceScalarField& phi,
const word modelName
)
:
mixtureViscosityModel(name, viscosityProperties, U, phi),
alpha_
(
U.mesh().lookupObject<volScalarField>
(
IOobject::groupName
(
viscosityProperties.lookupOrDefault<word>("alpha", "alpha"),
viscosityProperties.dictName()
)
)
)
{}
Foam::eddyViscosity<BasicTurbulenceModel>::eddyViscosity
(
const word& type,
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName
)
:
linearViscousStress<BasicTurbulenceModel>
(
type,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
nut_
(
IOobject
(
IOobject::groupName("nut", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
)
{}
dynLagrangianCsBound::dynLagrangianCsBound
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport,
const word& turbulenceModelName,
const word& modelName
)
:
LESModel(modelName, U, phi, transport, turbulenceModelName),
GenEddyVisc(U, phi, transport),
CsMin(0.07),
CsMax(0.14),
flm_
(
IOobject
(
"flm",
runTime_.timeName(),
mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh_
),
fmm_
(
IOobject
(
"fmm",
runTime_.timeName(),
mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh_
),
Cs_
(
IOobject
(
"Cs",
runTime_.timeName(),
mesh_,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
Foam::sqrt(flm_/fmm_)
),
theta_
(
dimensioned<scalar>::lookupOrAddToDict
(
"theta",
coeffDict_,
1.5
)
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_()),
flm0_("flm0", flm_.dimensions(), 0.0),
fmm0_("fmm0", fmm_.dimensions(), VSMALL)
{
updateSubGridScaleFields(fvc::grad(U));
printCoeffs();
}
kOmegaSSTSASnew<BasicTurbulenceModel>::kOmegaSSTSASnew
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
kOmegaSST<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
Cs_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cs",
this->coeffDict_,
0.262
)
),
kappa_
(
dimensioned<scalar>::lookupOrAddToDict
(
"kappa",
this->coeffDict_,
0.41
)
),
zeta2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"zeta2",
this->coeffDict_,
1.47
)
),
sigmaPhi_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmaPhi",
this->coeffDict_,
2.0/3.0
)
),
C_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C",
this->coeffDict_,
2
)
),
delta_
(
LESdelta::New
(
IOobject::groupName("delta", U.group()),
*this,
this->coeffDict_
)
)
{}
// Construct from components
Foam::spray::spray
(
const volVectorField& U,
const volScalarField& rho,
const volScalarField& p,
const volScalarField& T,
const basicMultiComponentMixture& composition,
const PtrList<gasThermoPhysics>& gasProperties,
const dictionary&,
const dimensionedVector& g,
bool readFields
)
:
Cloud<parcel>(U.mesh(), false), // suppress className checking on positions
runTime_(U.time()),
time0_(runTime_.value()),
mesh_(U.mesh()),
rndGen_(label(0)),
g_(g.value()),
U_(U),
rho_(rho),
p_(p),
T_(T),
sprayProperties_
(
IOobject
(
"sprayProperties",
U.time().constant(),
U.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
ambientPressure_(p_.average().value()),
ambientTemperature_(T_.average().value()),
injectors_
(
IOobject
(
"injectorProperties",
U.time().constant(),
U.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE
),
injector::iNew(U.time())
),
atomization_
(
atomizationModel::New
(
sprayProperties_,
*this
)
),
drag_
(
dragModel::New
(
sprayProperties_
)
),
evaporation_
(
evaporationModel::New
(
sprayProperties_
)
),
heatTransfer_
(
heatTransferModel::New
(
sprayProperties_
)
),
wall_
(
wallModel::New
(
sprayProperties_,
U,
*this
)
),
breakupModel_
(
breakupModel::New
(
sprayProperties_,
*this
)
),
collisionModel_
(
collisionModel::New
(
sprayProperties_,
*this,
rndGen_
)
),
dispersionModel_
(
dispersionModel::New
(
sprayProperties_,
*this
)
),
fuels_
(
liquidMixture::New
(
mesh_.lookupObject<dictionary>("thermophysicalProperties")
)
),
injectorModel_
(
injectorModel::New
(
sprayProperties_,
*this
)
),
sprayIteration_(sprayProperties_.subDict("sprayIteration")),
sprayIterate_(readLabel(sprayIteration_.lookup("sprayIterate"))),
sprayRelaxFactor_(readScalar(sprayIteration_.lookup("sprayRelaxFactor"))),
minimumParcelMass_
(
readScalar(sprayIteration_.lookup("minimumParcelMass"))
),
subCycles_(readLabel(sprayProperties_.lookup("subCycles"))),
gasProperties_(gasProperties),
composition_(composition),
liquidToGasIndex_(fuels_->components().size(), -1),
gasToLiquidIndex_(composition.Y().size(), -1),
isLiquidFuel_(composition.Y().size(), false),
twoD_(0),
axisOfSymmetry_(vector::zero),
axisOfWedge_(vector(0,0,0)),
axisOfWedgeNormal_(vector(0,0,0)),
angleOfWedge_(0.0),
interpolationSchemes_(sprayProperties_.subDict("interpolationSchemes")),
UInterpolator_(NULL),
rhoInterpolator_(NULL),
pInterpolator_(NULL),
TInterpolator_(NULL),
sms_(mesh_.nCells(), vector::zero),
shs_(mesh_.nCells(), 0.0),
srhos_(fuels_->components().size()),
totalInjectedLiquidMass_(0.0),
injectedLiquidKE_(0.0)
{
// create the evaporation source fields
forAll(srhos_, i)
{
srhos_.set(i, new scalarField(mesh_.nCells(), 0.0));
}
Foam::XPP_DE::XPP_DE
(
const word& name,
const volVectorField& U,
const surfaceScalarField& phi,
const dictionary& dict
)
:
viscoelasticLaw(name, U, phi),
S_
(
IOobject
(
"S" + name,
U.time().timeName(),
U.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
U.mesh()
),
Lambda_
(
IOobject
(
"Lambda" + name,
U.time().timeName(),
U.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
U.mesh()
),
tau_
(
IOobject
(
"tau" + name,
U.time().timeName(),
U.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
U.mesh(),
dimensionedSymmTensor
(
"zero",
dimensionSet(1, -1, -2, 0, 0, 0, 0),
symmTensor::zero
)
),
I_
(
dimensionedSymmTensor
(
"I",
dimensionSet(0, 0, 0, 0, 0, 0, 0),
symmTensor
(
1, 0, 0,
1, 0,
1
)
)
),
rho_(dict.lookup("rho")),
etaS_(dict.lookup("etaS")),
etaP_(dict.lookup("etaP")),
alpha_(dict.lookup("alpha")),
lambdaOb_(dict.lookup("lambdaOb")),
lambdaOs_(dict.lookup("lambdaOs")),
q_(dict.lookup("q"))
{}
kEpsilonSources::kEpsilonSources
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport,
const word& turbulenceModelName,
const word& modelName
)
:
RASModel(modelName, U, phi, transport, turbulenceModelName),
Cmu_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmu",
coeffDict_,
0.09
)
),
C1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1",
coeffDict_,
1.44
)
),
C2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C2",
coeffDict_,
1.92
)
),
sigmaEps_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmaEps",
coeffDict_,
1.3
)
),
k_
(
IOobject
(
"k",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateK("k", mesh_)
),
epsilon_
(
IOobject
(
"epsilon",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateEpsilon("epsilon", mesh_)
),
nut_
(
IOobject
(
"nut",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateNut("nut", mesh_)
),
fvOptions(U.mesh())
{
bound(k_, kMin_);
bound(epsilon_, epsilonMin_);
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
printCoeffs();
}
bool Foam::cfdemCloud::evolve
(
volScalarField& alpha,
volVectorField& Us,
volVectorField& U
)
{
numberOfParticlesChanged_ = false;
arraysReallocated_=false;
bool doCouple=false;
if(!ignore())
{
if (dataExchangeM().couple())
{
Info << "\n Coupling..." << endl;
doCouple=true;
// reset vol Fields
clockM().start(16,"resetVolFields");
if(verbose_)
{
Info << "couplingStep:" << dataExchangeM().couplingStep()
<< "\n- resetVolFields()" << endl;
}
averagingM().resetVectorAverage(averagingM().UsPrev(),averagingM().UsNext());
voidFractionM().resetVoidFractions();
averagingM().resetVectorAverage(forceM(0).impParticleForces(),forceM(0).impParticleForces(),true);
averagingM().resetVectorAverage(forceM(0).expParticleForces(),forceM(0).expParticleForces(),true);
averagingM().resetWeightFields();
for (int i=0;i<momCoupleModels_.size(); i++)
momCoupleM(i).resetMomSourceField();
if(verbose_) Info << "resetVolFields done." << endl;
clockM().stop("resetVolFields");
if(verbose_) Info << "- getDEMdata()" << endl;
clockM().start(17,"getDEMdata");
getDEMdata();
clockM().stop("getDEMdata");
if(verbose_) Info << "- getDEMdata done." << endl;
// search cellID of particles
clockM().start(18,"findCell");
if(verbose_) Info << "- findCell()" << endl;
findCells();
if(verbose_) Info << "findCell done." << endl;
clockM().stop("findCell");
// set void fraction field
clockM().start(19,"setvoidFraction");
if(verbose_) Info << "- setvoidFraction()" << endl;
voidFractionM().setvoidFraction(NULL,voidfractions_,particleWeights_,particleVolumes_);
if(verbose_) Info << "setvoidFraction done." << endl;
clockM().stop("setvoidFraction");
// set particles velocity field
clockM().start(20,"setVectorAverage");
setVectorAverages();
clockM().stop("setVectorAverage");
// set particles forces
clockM().start(21,"setForce");
if(verbose_) Info << "- setForce(forces_)" << endl;
setForces();
if(verbose_) Info << "setForce done." << endl;
clockM().stop("setForce");
// get next force field
clockM().start(22,"setParticleForceField");
if(verbose_) Info << "- setParticleForceField()" << endl;
averagingM().setVectorSum
(
forceM(0).impParticleForces(),
impForces_,
particleWeights_,
NULL //mask
);
averagingM().setVectorSum
(
forceM(0).expParticleForces(),
expForces_,
particleWeights_,
NULL //mask
);
if(verbose_) Info << "- setParticleForceField done." << endl;
clockM().stop("setParticleForceField");
// write DEM data
if(verbose_) Info << " -giveDEMdata()" << endl;
clockM().start(23,"giveDEMdata");
giveDEMdata();
clockM().stop("giveDEMdata");
}//end dataExchangeM().couple()
Info << "\n timeStepFraction() = " << dataExchangeM().timeStepFraction() << endl;
clockM().start(24,"interpolateEulerFields");
// update smoothing model
smoothingM().dSmoothing();
//============================================
// update voidFractionField V1
alpha = voidFractionM().voidFractionInterp();
smoothingM().smoothen(alpha);
if(dataExchangeM().couplingStep() < 2)
{
alpha.oldTime() = alpha; // supress volume src
alpha.oldTime().correctBoundaryConditions();
}
alpha.correctBoundaryConditions();
// calc ddt(voidfraction)
//calcDdtVoidfraction(voidFractionM().voidFractionNext());
calcDdtVoidfraction(alpha);
// update particle velocity Field
Us = averagingM().UsInterp();
//smoothingM().smoothenReferenceField(Us);
Us.correctBoundaryConditions();
/*//============================================
// update voidFractionField
volScalarField oldAlpha = alpha.oldTime(); //save old (smooth) alpha field
alpha.oldTime().internalField() = voidFractionM().voidFractionInterp();
smoothingM().smoothen(alpha);
alpha.correctBoundaryConditions();
alpha.oldTime() = oldAlpha; //set old (smooth) alpha field to allow correct computation of ddt
// calc ddt(voidfraction)
if (doCouple) calcDdtVoidfraction(alpha);
//calcDdtVoidfraction(alpha); // alternative with scale=1! (does not see change in alpha?)
// update particle velocity Field
Us.oldTime().internalField() = averagingM().UsInterp();
smoothingM().smoothenReferenceField(Us);
Us.correctBoundaryConditions();
//============================================*/
clockM().stop("interpolateEulerFields");
if(verbose_){
#include "debugInfo.H"
}
clockM().start(25,"dumpDEMdata");
// do particle IO
IOM().dumpDEMdata();
clockM().stop("dumpDEMdata");
}//end ignore
return doCouple;
}
void averagingModel::resetVectorAverage(volVectorField& prev,volVectorField& next,bool single) const
{
if(!single) prev.internalField() = next.internalField();
next.internalField() = vector::zero;
}
mixtureKEpsilon<BasicTurbulenceModel>::mixtureKEpsilon
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
eddyViscosity<RASModel<BasicTurbulenceModel> >
(
type,
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName
),
liquidTurbulencePtr_(NULL),
Cmu_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmu",
this->coeffDict_,
0.09
)
),
C1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1",
this->coeffDict_,
1.44
)
),
C2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C2",
this->coeffDict_,
1.92
)
),
C3_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C3",
this->coeffDict_,
C2_.value()
)
),
Cp_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cp",
this->coeffDict_,
0.25
)
),
sigmak_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmak",
this->coeffDict_,
1.0
)
),
sigmaEps_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmaEps",
this->coeffDict_,
1.3
)
),
k_
(
IOobject
(
IOobject::groupName("k", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
),
epsilon_
(
IOobject
(
IOobject::groupName("epsilon", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
)
{
bound(k_, this->kMin_);
bound(epsilon_, this->epsilonMin_);
if (type == typeName)
{
this->printCoeffs(type);
}
}
tmp<fvVectorMatrix> surfaceShearForce::correct(volVectorField& U)
{
// local reference to film model
const kinematicSingleLayer& film =
static_cast<const kinematicSingleLayer&>(owner_);
// local references to film fields
const volScalarField& mu = film.mu();
const volVectorField& Uw = film.Uw();
const volScalarField& delta = film.delta();
const volVectorField& Up = film.UPrimary();
// film surface linear coeff to apply to velocity
tmp<volScalarField> tCs;
typedef compressible::turbulenceModel turbModel;
if (film.primaryMesh().foundObject<turbModel>("turbulenceProperties"))
{
// local reference to turbulence model
const turbModel& turb =
film.primaryMesh().lookupObject<turbModel>("turbulenceProperties");
// calculate and store the stress on the primary region
const volSymmTensorField primaryReff(turb.devRhoReff());
// create stress field on film
// - note boundary condition types (mapped)
// - to map, the field name must be the same as the field on the
// primary region
volSymmTensorField Reff
(
IOobject
(
primaryReff.name(),
film.regionMesh().time().timeName(),
film.regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
film.regionMesh(),
dimensionedSymmTensor
(
"zero",
primaryReff.dimensions(),
symmTensor::zero
),
film.mappedFieldAndInternalPatchTypes<symmTensor>()
);
// map stress from primary region to film region
Reff.correctBoundaryConditions();
dimensionedScalar U0("SMALL", U.dimensions(), SMALL);
tCs = Cf_*mag(-film.nHat() & Reff)/(mag(Up - U) + U0);
}
else
{
// laminar case - employ simple coeff-based model
const volScalarField& rho = film.rho();
tCs = Cf_*rho*mag(Up - U);
}
dimensionedScalar d0("SMALL", delta.dimensions(), SMALL);
// linear coeffs to apply to velocity
const volScalarField& Cs = tCs();
volScalarField Cw("Cw", mu/(0.3333*(delta + d0)));
Cw.min(1.0e+06);
return
(
- fvm::Sp(Cs, U) + Cs*Up // surface contribution
- fvm::Sp(Cw, U) + Cw*Uw // wall contribution
);
}
Foam::autoPtr<Foam::laminarModel<BasicTurbulenceModel>>
Foam::laminarModel<BasicTurbulenceModel>::New
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName
)
{
IOdictionary modelDict
(
IOobject
(
IOobject::groupName(propertiesName, U.group()),
U.time().constant(),
U.db(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
);
if (modelDict.found("laminar"))
{
// get model name, but do not register the dictionary
// otherwise it is registered in the database twice
const word modelType
(
modelDict.subDict("laminar").lookup("laminarModel")
);
Info<< "Selecting laminar stress model " << modelType << endl;
typename dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(modelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown laminarModel type "
<< modelType << nl << nl
<< "Valid laminarModel types:" << endl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
return autoPtr<laminarModel>
(
cstrIter()
(
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport, propertiesName)
);
}
else
{
Info<< "Selecting laminar stress model "
<< laminarModels::Stokes<BasicTurbulenceModel>::typeName << endl;
return autoPtr<laminarModel>
(
new laminarModels::Stokes<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
)
);
}
}
RNGkEpsilon<BasicTurbulenceModel>::RNGkEpsilon
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
eddyViscosity<RASModel<BasicTurbulenceModel> >
(
type,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
Cmu_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmu",
this->coeffDict_,
0.0845
)
),
C1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1",
this->coeffDict_,
1.42
)
),
C2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C2",
this->coeffDict_,
1.68
)
),
C3_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C3",
this->coeffDict_,
-0.33
)
),
sigmak_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmak",
this->coeffDict_,
0.71942
)
),
sigmaEps_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmaEps",
this->coeffDict_,
0.71942
)
),
eta0_
(
dimensioned<scalar>::lookupOrAddToDict
(
"eta0",
this->coeffDict_,
4.38
)
),
beta_
(
dimensioned<scalar>::lookupOrAddToDict
(
"beta",
this->coeffDict_,
0.012
)
),
k_
(
IOobject
(
IOobject::groupName("k", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
),
epsilon_
(
IOobject
(
IOobject::groupName("epsilon", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
)
{
bound(k_, this->kMin_);
bound(epsilon_, this->epsilonMin_);
if (type == typeName)
{
correctNut();
this->printCoeffs(type);
}
}
