// Construct from components
virtualMassForce::virtualMassForce
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
UrelOld_(NULL)
{
if (propsDict_.found("verbose")) verbose_=true;
if (particleCloud_.dataExchangeM().maxNumberOfParticles() > 0)
{
// get memory for 2d array
particleCloud_.dataExchangeM().allocateArray(UrelOld_,0.,3);
}
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
particleCloud_.checkCG(true);
}
// Construct from components
brownianForce::brownianForce
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
lambda_(readScalar(propsDict_.lookup("lambda"))),
temperature_(readScalar(propsDict_.lookup("temperature")))
//rndGen_(label(0), -1)
//rndGen_(time(NULL), -1)
{
if (propsDict_.found("verbose")) verbose_=true;
Info << "brownianForce is applied only to DEM side" << endl;
seed_=(scalar)(time(NULL));
save_ = 0;
dt_ = U_.mesh().time().deltaT().value();
}
// Construct from components
SchillerNaumannDrag::SchillerNaumannDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_))
{
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "schillerNaumannDrag.logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("Cd"); //other are debug
particleCloud_.probeM().writeHeader();
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
particleCloud_.checkCG(false);
if(particleCloud_.dispersionM().isActive())
{
Info << "Turbulent dispersion enabled."<< endl;
}
}
// Construct from components
viscForce::viscForce
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velocityFieldName_(propsDict_.lookup("velocityFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velocityFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
interpolation_(false)
{
if (modelType_ == "B")
{
FatalError <<"using model viscForce with model type B is not valid\n" << abort(FatalError);
} else
{
treatDEM_=true;
Info << "viscForce is applied only to DEM side" << endl;
}
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation"))
{
Info << "using interpolated value of pressure gradient." << endl;
interpolation_=true;
}
particleCloud_.checkCG(true);
}
// Construct from components
DiFeliceDrag::DiFeliceDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
interpolation_(false)
{
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "diFeliceDrag.logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("Cd"); //other are debug
particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug
particleCloud_.probeM().writeHeader();
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation"))
{
Info << "using interpolated value of U." << endl;
interpolation_=true;
}
particleCloud_.checkCG(false);
}
// Construct from components
DiFeliceDrag::DiFeliceDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
interpolation_(false)
{
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation"))
{
Info << "using interpolated value of U." << endl;
interpolation_=true;
}
particleCloud_.checkCG(false);
}
// Construct from components
virtualMassForce::virtualMassForce
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
phiFieldName_(propsDict_.lookup("phiFieldName")),
phi_(sm.mesh().lookupObject<surfaceScalarField> (phiFieldName_)),
UrelOld_(NULL),
splitUrelCalculation_(false),
Cadd_(0.5)
{
if (particleCloud_.dataExchangeM().maxNumberOfParticles() > 0)
{
// get memory for 2d array
particleCloud_.dataExchangeM().allocateArray(UrelOld_,NOTONCPU,3);
}
// init force sub model
setForceSubModels(propsDict_);
// define switches which can be read from dict
forceSubM(0).setSwitchesList(0,true); // activate treatExplicit switch
forceSubM(0).setSwitchesList(4,true); // activate search for interpolate switch
forceSubM(0).readSwitches();
//Extra switches/settings
if(propsDict_.found("splitUrelCalculation"))
{
splitUrelCalculation_ = readBool(propsDict_.lookup("splitUrelCalculation"));
if(splitUrelCalculation_)
Info << "Virtual mass model: will split the Urel calculation\n";
Info << "WARNING: be sure that LIGGGHTS integration takes ddtv_p implicitly into account! \n";
}
if(propsDict_.found("Cadd"))
{
Cadd_ = readScalar(propsDict_.lookup("Cadd"));
Info << "Virtual mass model: using non-standard Cadd = " << Cadd_ << endl;
}
particleCloud_.checkCG(true);
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "virtualMass.logDat");
particleCloud_.probeM().vectorFields_.append("virtualMassForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel");
particleCloud_.probeM().vectorFields_.append("UrelOld");
particleCloud_.probeM().vectorFields_.append("ddtUrel");
particleCloud_.probeM().scalarFields_.append("Vs");
particleCloud_.probeM().scalarFields_.append("rho");
particleCloud_.probeM().writeHeader();
}
// Construct from components
gradPForce::gradPForce
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
pFieldName_(propsDict_.lookup("pFieldName")),
p_(sm.mesh().lookupObject<volScalarField> (pFieldName_)),
velocityFieldName_(propsDict_.lookup("velocityFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velocityFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
useRho_(false),
useU_(false),
addedMassCoeff_(0.0),
interpolation_(false)
{
if (modelType_ == "B")
{
FatalError <<"using model gradPForce with model type B is not valid\n" << abort(FatalError);
}else
{
treatDEM_=true;
Info << "gradPForce is applied only to DEM side" << endl;
}
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("useU")) useU_=true;
if (propsDict_.found("useAddedMass"))
{
addedMassCoeff_ = readScalar(propsDict_.lookup("useAddedMass"));
Info << "gradP will also include added mass with coefficient: " << addedMassCoeff_ << endl;
Info << "WARNING: use fix nve/sphere/addedMass in LIGGGHTS input script to correctly account for added mass effects!" << endl;
}
if (propsDict_.found("interpolation"))
{
Info << "using interpolated value of pressure gradient." << endl;
interpolation_=true;
}
if(p_.dimensions()==dimensionSet(0,2,-2,0,0))
useRho_ = true;
particleCloud_.checkCG(true);
particleCloud_.probeM().initialize(typeName, "gradP.logDat");
particleCloud_.probeM().vectorFields_.append("gradPForce"); //first entry must the be the force
particleCloud_.probeM().scalarFields_.append("Vs");
particleCloud_.probeM().scalarFields_.append("rho");
particleCloud_.probeM().writeHeader();
}
// Construct from components
GidaspowDrag::GidaspowDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
phi_(readScalar(propsDict_.lookup("phi"))),
interpolation_(false),
scaleDia_(1.),
scaleDrag_(1.)
{
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "gidaspowDrag.logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must be the force
particleCloud_.probeM().vectorFields_.append("Urel");
particleCloud_.probeM().scalarFields_.append("Rep");
particleCloud_.probeM().scalarFields_.append("betaP");
particleCloud_.probeM().scalarFields_.append("voidfraction");
particleCloud_.probeM().writeHeader();
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation")) interpolation_=true;
if (propsDict_.found("implDEM"))
{
treatExplicit_=false;
implDEM_=true;
setImpDEMdrag();
Info << "Using implicit DEM drag formulation." << endl;
}
particleCloud_.checkCG(true);
if (propsDict_.found("scale"))
scaleDia_=scalar(readScalar(propsDict_.lookup("scale")));
if (propsDict_.found("scaleDrag"))
scaleDrag_=scalar(readScalar(propsDict_.lookup("scaleDrag")));
Info << "Gidaspow - interpolation switch: " << interpolation_ << endl;
if(particleCloud_.dispersionM().isActive())
{
Info << "Turbulent dispersion enabled."<< endl;
}
}
// Construct from components
DiFeliceDrag::DiFeliceDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
interpolation_(false),
splitImplicitExplicit_(false),
UsFieldName_(propsDict_.lookup("granVelFieldName")),
UsField_(sm.mesh().lookupObject<volVectorField> (UsFieldName_)),
scaleDia_(1.),
scaleDrag_(1.)
{
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "diFeliceDrag.logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("Cd"); //other are debug
particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug
particleCloud_.probeM().writeHeader();
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation"))
{
Info << "using interpolated value of U." << endl;
interpolation_=true;
}
if (propsDict_.found("splitImplicitExplicit"))
{
Info << "will split implicit / explicit force contributions." << endl;
splitImplicitExplicit_ = true;
if(!interpolation_)
Info << "WARNING: will only consider fluctuating particle velocity in implicit / explicit force split!" << endl;
}
particleCloud_.checkCG(true);
if (propsDict_.found("scale"))
scaleDia_=scalar(readScalar(propsDict_.lookup("scale")));
if (propsDict_.found("scaleDrag"))
scaleDrag_=scalar(readScalar(propsDict_.lookup("scaleDrag")));
}
// Construct from components
KochHillDrag::KochHillDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
UsFieldName_(propsDict_.lookupOrDefault("granVelFieldName",word("Us"))),
UsField_(sm.mesh().lookupObject<volVectorField> (UsFieldName_))
{
// suppress particle probe
if (probeIt_ && propsDict_.found("suppressProbe"))
probeIt_=!Switch(propsDict_.lookup("suppressProbe"));
if(probeIt_)
{
particleCloud_.probeM().initialize(typeName, typeName+".logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("beta"); //other are debug
particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug
particleCloud_.probeM().writeHeader();
}
// init force sub model
setForceSubModels(propsDict_);
// define switches which can be read from dict
forceSubM(0).setSwitchesList(0,true); // activate search for treatExplicit switch
forceSubM(0).setSwitchesList(2,true); // activate search for implDEM switch
forceSubM(0).setSwitchesList(3,true); // activate search for verbose switch
forceSubM(0).setSwitchesList(4,true); // activate search for interpolate switch
forceSubM(0).setSwitchesList(7,true); // activate implForceDEMacc switch
forceSubM(0).setSwitchesList(8,true); // activate scalarViscosity switch
// read those switches defined above, if provided in dict
for (int iFSub=0;iFSub<nrForceSubModels();iFSub++)
forceSubM(iFSub).readSwitches();
particleCloud_.checkCG(true);
}
autoPtr<scalarTransportModel> scalarTransportModel::New
(
const dictionary& dict, //Not used at the moment
cfdemCloud& sm
)
{
IOdictionary tempDict
(
IOobject
(
"scalarTransportProperties",
sm.mesh().time().constant(),
sm.mesh(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
word scalarTransportModelType
(
tempDict.lookup("scalarTransportModel")
);
Info<< "Selecting scalarTransportModel "
<< scalarTransportModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(scalarTransportModelType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalError
<< "scalarTransportModel::New(const dictionary&, const spray&) : "
<< endl
<< " unknown scalarTransportModelType type "
<< scalarTransportModelType
<< ", constructor not in hash table" << endl << endl
<< " Valid scalarTransportModel types are :"
<< endl;
Info<< dictionaryConstructorTablePtr_->toc()
<< abort(FatalError);
}
return autoPtr<scalarTransportModel>(cstrIter()(tempDict,sm));
}
// Construct from components
DiFeliceDrag::DiFeliceDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
UsFieldName_(propsDict_.lookup("granVelFieldName")),
UsField_(sm.mesh().lookupObject<volVectorField> (UsFieldName_)),
scaleDia_(1.),
scaleDrag_(1.)
{
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "diFeliceDrag.logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("Cd"); //other are debug
particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug
particleCloud_.probeM().writeHeader();
particleCloud_.checkCG(true);
if (propsDict_.found("scale"))
scaleDia_=scalar(readScalar(propsDict_.lookup("scale")));
if (propsDict_.found("scaleDrag"))
scaleDrag_=scalar(readScalar(propsDict_.lookup("scaleDrag")));
// init force sub model
setForceSubModels(propsDict_);
// define switches which can be read from dict
forceSubM(0).setSwitchesList(0,true); // activate treatExplicit switch
forceSubM(0).setSwitchesList(2,true); // activate implDEM switch
forceSubM(0).setSwitchesList(3,true); // activate search for verbose switch
forceSubM(0).setSwitchesList(4,true); // activate search for interpolate switch
forceSubM(0).setSwitchesList(8,true); // activate scalarViscosity switch
// read those switches defined above, if provided in dict
forceSubM(0).readSwitches();
}
// Construct from components
GidaspowDrag::GidaspowDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_))
{
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
particleCloud_.checkCG(false);
}
// Construct from components
KochHillDrag::KochHillDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
interpolation_(false),
scale_(1.)
{
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "kochHillDrag.logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("beta"); //other are debug
particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug
particleCloud_.probeM().writeHeader();
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation")) interpolation_=true;
if (propsDict_.found("implDEM"))
{
treatExplicit_=false;
implDEM_=true;
setImpDEMdrag();
Info << "Using implicit DEM drag formulation." << endl;
}
particleCloud_.checkCG(true);
if (propsDict_.found("scale"))
scale_=scalar(readScalar(propsDict_.lookup("scale")));
}
// Construct from components
checkCouplingInterval::checkCouplingInterval
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
rhoP_(readScalar(propsDict_.lookup("rhoP")))
{}
// Construct from components
KochHillDrag::KochHillDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
interpolation_(false)
{
if (propsDict_.found("verbose")) verbose_=true;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation")) interpolation_=true;
if (propsDict_.found("scale"))
scale_=scalar(readScalar(propsDict_.lookup("scale")));
}
// Construct from components
interface::interface
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
VOFvoidfractionFieldName_(propsDict_.lookup("VOFvoidfractionFieldName")),
alpha_(sm.mesh().lookupObject<volScalarField> (VOFvoidfractionFieldName_)),
gradAlphaName_(propsDict_.lookup("gradAlphaName")),
gradAlpha_(sm.mesh().lookupObject<volVectorField> (gradAlphaName_)),
sigma_(readScalar(propsDict_.lookup("sigma"))),
theta_(readScalar(propsDict_.lookup("theta"))),
alphaThreshold_(readScalar(propsDict_.lookup("alphaThreshold"))),
deltaAlphaIn_(readScalar(propsDict_.lookup("deltaAlphaIn"))),
deltaAlphaOut_(readScalar(propsDict_.lookup("deltaAlphaOut"))),
C_(1.0),
interpolation_(false)
{
if (propsDict_.found("C")) C_=readScalar(propsDict_.lookup("C"));
// init force sub model
setForceSubModels(propsDict_);
// define switches which can be read from dict
forceSubM(0).setSwitchesList(0,true); // activate treatExplicit switch
forceSubM(0).setSwitchesList(4,true); // activate search for interpolate switch
// read those switches defined above, if provided in dict
forceSubM(0).readSwitches();
//for (int iFSub=0;iFSub<nrForceSubModels();iFSub++)
// forceSubM(iFSub).readSwitches();
particleCloud_.checkCG(false);
}
// Construct from components
IOModel::IOModel
(
const dictionary& dict,
cfdemCloud& sm
)
:
dict_(dict),
particleCloud_(sm),
time_(sm.mesh().time()),
parOutput_(true)
{
if (
particleCloud_.dataExchangeM().myType()=="oneWayVTK" ||
dict_.found("serialOutput")
)
{
parOutput_=false;
Warning << "IO model is in serial write mode, only data on proc 0 is written" << endl;
}
}
// Construct from components
averagingModel::averagingModel
(
const dictionary& dict,
cfdemCloud& sm
)
:
dict_(dict),
particleCloud_(sm),
UsWeightField_
(
IOobject
(
"UsWeightField_",
particleCloud_.mesh().time().timeName(),
particleCloud_.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
particleCloud_.mesh(),
dimensionedScalar("zero", dimensionSet(0,0,0,0,0), 0.0)
),
UsPrev_
( IOobject
(
"UsPrev",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,//MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh().lookupObject<volVectorField> ("Us")
/*sm.mesh(),
dimensionedVector("zero", dimensionSet(0,1,-1,0,0),vector::zero)*/
),
UsNext_
( IOobject
(
"UsNext",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,//MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh().lookupObject<volVectorField> ("Us")
/*sm.mesh(),
dimensionedVector("zero", dimensionSet(0,1,-1,0,0),vector::zero)*/
)
{}
// Construct from components
MeiLift::MeiLift
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
useSecondOrderTerms_(false)
{
if (propsDict_.found("useSecondOrderTerms")) useSecondOrderTerms_=true;
// init force sub model
setForceSubModels(propsDict_);
// define switches which can be read from dict
forceSubM(0).setSwitchesList(0,true); // activate treatExplicit switch
forceSubM(0).setSwitchesList(3,true); // activate search for verbose switch
forceSubM(0).setSwitchesList(4,true); // activate search for interpolate switch
forceSubM(0).setSwitchesList(8,true); // activate scalarViscosity switch
//set default switches (hard-coded default = false)
forceSubM(0).setSwitches(0,true); // enable treatExplicit, otherwise this force would be implicit in slip vel! - IMPORTANT!
for (int iFSub=0;iFSub<nrForceSubModels();iFSub++)
forceSubM(iFSub).readSwitches();
particleCloud_.checkCG(false);
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, typeName+".logDat");
particleCloud_.probeM().vectorFields_.append("liftForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().vectorFields_.append("vorticity"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rew"); //other are debug
particleCloud_.probeM().scalarFields_.append("J_star"); //other are debug
particleCloud_.probeM().writeHeader();
}
// Construct from components
forceModel::forceModel
(
const dictionary& dict,
cfdemCloud& sm
)
:
dict_(dict),
particleCloud_(sm),
treatExplicit_(false),
treatDEM_(false),
impParticleForces_
( IOobject
(
"impParticleForces",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
sm.mesh(),
dimensionedVector("zero", dimensionSet(1,1,-2,0,0), vector(0,0,0)) // N
),
expParticleForces_
( IOobject
(
"expParticleForces",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
sm.mesh(),
dimensionedVector("zero", dimensionSet(1,1,-2,0,0), vector(0,0,0)) // N
),
coupleForce_(true),
modelType_(sm.modelType()),
scale_(1.)
{}
// Construct from components
voidFractionModel::voidFractionModel
(
const dictionary& dict,
cfdemCloud& sm
)
:
dict_(dict),
particleCloud_(sm),
voidfractionPrev_
( IOobject
(
"voidfractionPrev",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,//MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh().lookupObject<volScalarField> ("voidfraction")
/*sm.mesh(),
dimensionedScalar("zero", dimensionSet(0,0,0,0,0), 1)*/
),
voidfractionNext_
( IOobject
(
"voidfractionNext",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,//MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh().lookupObject<volScalarField> ("voidfraction")
/*sm.mesh(),
dimensionedScalar("zero", dimensionSet(0,0,0,0,0), 1)*/
),
cellsPerParticle_(NULL),
maxCellsPerParticle_(1),
weight_(1.),
porosity_(1.),
requiresSuperquadric_(false)
{
particleCloud_.dataExchangeM().allocateArray(cellsPerParticle_,1,maxCellsPerParticle_);
}
void createParcels
(
const fvMesh& mesh,
cfdemCloud& sm,
const int& parcelSize_,
int**& parcelCloud_,
double**& parcelPositions_,
double**& parcelVelocities_,
int*& parcelNparts_,
double** & parcelKinStress_,
scalar& aveSubQparcel2_,
vector& meanParcelVel_,
const bool verbose_
)
{
if ( parcelSize_ * parcelSize_ * parcelSize_ > sm.numberOfParticles() )
{
FatalError << " Number of particles in a parcel > number of particles" << abort(FatalError);
}
if ( parcelSize_ < 1 )
{
FatalError << " Number of particles < 0 in a parcel " << abort(FatalError);
}
// Number of particles in a parcel
int k = parcelSize_ * parcelSize_ * parcelSize_;
// Dimensions, exact OR approximate
int dim =3; double eps = 0;
// Number of points
int nPts;
nPts = sm.numberOfParticles();
// Data points
ANNpointArray dataPts;
// Query points
ANNpoint queryPt;
ANNidxArray nnIdx; // near neighbour indices
ANNdistArray dists; // near neighbour distances
ANNkd_tree* kdTree; // search structure
// Allocate
queryPt = annAllocPt(dim);
dataPts = annAllocPts(nPts, dim);
nnIdx = new ANNidx[k];
dists = new ANNdist[k];
for(int index = 0; index < sm.numberOfParticles(); index++)
{
dataPts[index][0] = sm.position(index).x();
dataPts[index][1] = sm.position(index).y();
dataPts[index][2] = sm.position(index).z();
}
kdTree = new ANNkd_tree(dataPts, nPts, dim);
// Initialize sub-parcel agitation
aveSubQparcel2_ = 0.;
// Initialize parcel velocity
meanParcelVel_ = vector(0,0,0);
for(int index = 0; index < sm.numberOfParticles(); index++)
{
// Particle neighbouring search distance
scalar sqRad = parcelSize_ * sm.radius(index);
queryPt[0] = sm.position(index).x();
queryPt[1] = sm.position(index).y();
queryPt[2] = sm.position(index).z();
kdTree->annkFRSearch(
queryPt, // query point
sqRad, // squared radius
k, // number of the near neighbours to return
nnIdx, // nearest neighbor array
dists, // dist to near neighbours
eps );
int nParts = 0;
scalar dist = 0;
// Initialize parcel velocities & positions & kinetic stresses
for(int j=0;j<3;j++)
{
parcelVelocities_[index][j] = 0.;
parcelPositions_[index][j] = 0.;
parcelKinStress_[index][j] = 0.;
parcelKinStress_[index][2*j] = 0.;
}
for (int i = 0; i < k; i++)
{
parcelCloud_[index][i] = nnIdx[i];
dist = mag( sm.position(nnIdx[i]) - sm.position(index) ) - sqRad;
if ( dist < SMALL )
{
for(int j=0;j<3;j++)
{
// Parcel velocity
parcelVelocities_[index][j] += sm.velocity(nnIdx[i])[j];
// Parcel center of mass
parcelPositions_[index][j] += sm.position(nnIdx[i])[j];
}
nParts++;
}
}
for(int j=0;j<3;j++) parcelPositions_[index][j] /= nParts;
parcelNparts_[index] = nParts;
// Parcel kinetic stresses
for(int i = 0; i < parcelNparts_[index]; i++)
{
int particleID = parcelCloud_[index][i];
// U'xU'x
parcelKinStress_[index][0] += ( sm.velocity(particleID)[0] - parcelVelocities_[index][0] )
*( sm.velocity(particleID)[0] - parcelVelocities_[index][0] );
// U'yU'y
parcelKinStress_[index][1] += ( sm.velocity(particleID)[1] - parcelVelocities_[index][1] )
*( sm.velocity(particleID)[1] - parcelVelocities_[index][1] );
// U'zU'z
parcelKinStress_[index][2] += ( sm.velocity(particleID)[2] - parcelVelocities_[index][2] )
*( sm.velocity(particleID)[2] - parcelVelocities_[index][2] );
// U'xU'y
parcelKinStress_[index][3] += ( sm.velocity(particleID)[0] - parcelVelocities_[index][0] )
*( sm.velocity(particleID)[1] - parcelVelocities_[index][1] );
// U'xU'z
parcelKinStress_[index][4] += ( sm.velocity(particleID)[0] - parcelVelocities_[index][0] )
*( sm.velocity(particleID)[2] - parcelVelocities_[index][2] );
// U'yU'z
parcelKinStress_[index][5] += ( sm.velocity(particleID)[1] - parcelVelocities_[index][1] )
*( sm.velocity(particleID)[2] - parcelVelocities_[index][2] );
}
// Mean parcel velocity
for(int j=0;j<3;j++) meanParcelVel_[j] += parcelVelocities_[index][j];
// Domain-averaged parcel agitation
aveSubQparcel2_ += 1./2. * ( parcelKinStress_[index][0] + parcelKinStress_[index][1] + parcelKinStress_[index][2] );
}
for(int j=0;j<3;j++) meanParcelVel_[j] /= sm.numberOfParticles();
if ( verbose_ )
{
int index = 0;
Info << " Parcel particle list ";
for (int i = 0; i < parcelNparts_[index]; i++)
{
Info << parcelCloud_[index][i] << " " ;
}
Info << endl;
Info << " Parcel center " << parcelPositions_[index][0] << "," << parcelPositions_[index][1] << "," << parcelPositions_[index][2] << endl;
Info << " Parcel velocity " << parcelVelocities_[index][0] << "," << parcelVelocities_[index][1] << "," << parcelVelocities_[index][2] << endl;
for (int i = 0; i < parcelNparts_[index]; i++)
{
Info << " Particle " << parcelCloud_[index][i] << endl;
Info << " Particle center " << sm.position(parcelCloud_[index][i]) << endl;
Info << " Particle velocity " << sm.velocity(parcelCloud_[index][i]) << endl;
}
}
}
// Construct from components
BeetstraDrag::BeetstraDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
verbose_(false),
velFieldName_(propsDict_.lookup("velFieldName")),
U_(sm.mesh().lookupObject<volVectorField> (velFieldName_)),
densityFieldName_(propsDict_.lookup("densityFieldName")),
rho_(sm.mesh().lookupObject<volScalarField> (densityFieldName_)),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")),
voidfraction_(sm.mesh().lookupObject<volScalarField> (voidfractionFieldName_)),
gravityFieldName_(propsDict_.lookup("gravityFieldName")),
#if defined(version21) || defined(version16ext)
g_(sm.mesh().lookupObject<uniformDimensionedVectorField> (gravityFieldName_)),
#elif defined(version15)
g_(dimensionedVector(sm.mesh().lookupObject<IOdictionary>("environmentalProperties").lookup(gravityFieldName_)).value()),
#endif
dPrim_(1.0),
rhoParticle_(0.0),
interpolation_(false),
scale_(1.),
useFilteredDragModel_(false),
useParcelSizeDependentFilteredDrag_(false),
filtDragParamsK_(0.),
filtDragParamsALimit_(0.),
filtDragParamsAExponent_(1.0),
filtDragParamsLChar2_(0.0),
basicCalculator_()
{
if (propsDict_.found("verbose")) verbose_=true;
basicCalculator_.verbose_=verbose_;
if (propsDict_.found("treatExplicit")) treatExplicit_=true;
if (propsDict_.found("interpolation")) interpolation_=true;
if (propsDict_.found("implDEM"))
{
treatExplicit_=false;
implDEM_=true;
setImpDEMdrag();
Info << "Using implicit DEM drag formulation." << endl;
}
if (propsDict_.found("useFilteredDragModel"))
{
useFilteredDragModel_ = true;
rhoParticle_= readScalar(propsDict_.lookup("rhoParticle"));
}
if (propsDict_.found("useParcelSizeDependentFilteredDrag"))
{
useParcelSizeDependentFilteredDrag_=true;
filtDragParamsK_ = readScalar(propsDict_.lookup("k"));
filtDragParamsALimit_ = readScalar(propsDict_.lookup("aLimit"));
filtDragParamsAExponent_ = readScalar(propsDict_.lookup("aExponent"));
}
if(useParcelSizeDependentFilteredDrag_)
{
useFilteredDragModel_ = true;
Info << "Beetstra drag model: forced the use of the filtered drag model\n";
}
particleCloud_.checkCG(true);
//Set the reference length scale from particle information
// get viscosity field
#ifdef comp
const volScalarField nufField = particleCloud_.turbulence().mu()/rho_;
#else
const volScalarField& nufField = particleCloud_.turbulence().nu();
#endif
scalar nuf(0);
scalar rho(0);
if (useFilteredDragModel_)
{
//select viscosity and density
//based on first value in the field
nuf = nufField[0];
rho = rho_[0];
dPrim_ = readScalar(propsDict_.lookup("dPrim"));
basicCalculator_.setupSettling
(
dPrim_,
rhoParticle_,
mag(g_).value(),
nuf*rho,
rho,
1 //drag law: 1...Beetstra
);
filtDragParamsLChar2_ = basicCalculator_.settling.Lchar2;
{
Info << "dPrim_: "
<< dPrim_ << tab << "[m]" << endl;
Info << "Reference length for filtered drag computations: "
<< filtDragParamsLChar2_ << tab << "[m]" << endl;
}
}
//Append the field names to be probed
particleCloud_.probeM().initialize(typeName, "beetstraDrag.logDat");
particleCloud_.probeM().vectorFields_.append("dragForce"); //first entry must the be the force
particleCloud_.probeM().vectorFields_.append("Urel"); //other are debug
particleCloud_.probeM().scalarFields_.append("Rep"); //other are debug
particleCloud_.probeM().scalarFields_.append("beta"); //other are debug
particleCloud_.probeM().scalarFields_.append("voidfraction"); //other are debug
particleCloud_.probeM().scalarFields_.append("filterDragPrefactor"); //other are debug
particleCloud_.probeM().writeHeader();
}
void EulerianParticleVelocityForce
(
cfdemCloud& sm,
const fvMesh& mesh,
volVectorField& Uf_,
volVectorField& Up_,
volScalarField& rho_,
volScalarField& alpf_,
volScalarField& Pg_,
volVectorField& MappedDragForce_,
const labelListList& particleList_,
const bool& weighting_
)
{
// Neighbouring cells
CPCCellToCellStencil neighbourCells(mesh);
// get viscosity field
#ifdef comp
const volScalarField nufField = sm.turbulence().mu()/rho_;
#else
const volScalarField& nufField = sm.turbulence().nu();
#endif
// Gas pressure gradient
volVectorField gradPg_ = fvc::grad(Pg_);
interpolationCellPoint<vector> gradPgInterpolator_(gradPg_);
// Local variables
label cellID(-1);
vector drag(0,0,0);
vector Ufluid(0,0,0);
vector position(0,0,0);
scalar voidfraction(1);
vector Up(0,0,0);
vector Ur(0,0,0);
scalar ds(0);
scalar nuf(0);
scalar rhof(0);
vector WenYuDrag(0,0,0);
interpolationCellPoint<scalar> voidfractionInterpolator_(alpf_);
interpolationCellPoint<vector> UInterpolator_(Uf_);
scalar dist_s(0);
scalar sumWeights(0);
scalarField weightScalar(27,scalar(0.0));
Field <Field <scalar> > particleWeights(particleList_.size(),weightScalar);
//Info << " particle size " << particleList_.size() << endl;
// Number of particle in a cell
scalarField np(mesh.cells().size(),scalar(0));
// Particle volume
scalar Volp(0);
vector gradPg_int(0,0,0);
for(int ii = 0; ii < particleList_.size(); ii++)
{
int index = particleList_[ii][0];
cellID = sm.cellIDs()[index][0];
position = sm.position(index);
Ufluid = UInterpolator_.interpolate(position,cellID);
Up = sm.velocity(index);
Ur = Ufluid-Up;
ds = 2*sm.radius(index);
// Calculate WenYu Drag
voidfraction = voidfractionInterpolator_.interpolate(position,cellID);
nuf = nufField[cellID];
rhof = rho_[cellID];
WenYuDragForce(Ur,ds,rhof,nuf,voidfraction,WenYuDrag);
Volp = ds*ds*ds*M_PI/6;
gradPg_int = gradPgInterpolator_.interpolate(position,cellID);
//if (cellID > -1) // particle centre is in domain
//{
if(weighting_)
{
labelList& cellsNeigh = neighbourCells[cellID];
sumWeights = 0;
dist_s = 0;
//Info << " index = " << index << " ii = " << ii << " cellID = " << cellID << endl;
forAll(cellsNeigh,jj)
{
// Find distances between particle and neighbouring cells
dist_s = mag(sm.mesh().C()[cellsNeigh[jj]]-position)/pow(sm.mesh().V()[cellsNeigh[jj]],1./3.);
if(dist_s <= 0.5)
{
particleWeights[ii][jj] = 1./4.*pow(dist_s,4)-5./8.*pow(dist_s,2)+115./192.;
}
else if (dist_s > 0.5 && dist_s <= 1.5)
{
particleWeights[ii][jj] = -1./6.*pow(dist_s,4)+5./6.*pow(dist_s,3)-5./4.*pow(dist_s,2)+5./24.*dist_s+55./96.;
}
else if (dist_s > 1.5 && dist_s <= 2.5)
{
particleWeights[ii][jj] = pow(2.5-dist_s,4)/24.;
}
else
{
particleWeights[ii][jj] = 0;
}
sumWeights += particleWeights[ii][jj];
}
forAll(cellsNeigh,jj)
{
if ( sumWeights != 0 )
{
Up_[cellID] += Up*particleWeights[ii][jj]/sumWeights;
MappedDragForce_[cellID] += (WenYuDrag + Volp * gradPg_int) * particleWeights[ii][jj]/sumWeights;
}
else
{
Up_[cellID] = vector(0,0,0);
MappedDragForce_[cellID] = vector(0,0,0);
}
}
}
else
{
void CalculateDragForce
(
cfdemCloud& sm,
const volScalarField& alpf_,
const volVectorField& Uf_,
const volScalarField& rho_,
const bool& verbose_,
vectorField& DragForce_,
const labelListList& particleList_
)
{
// get viscosity field
#ifdef comp
const volScalarField nufField = sm.turbulence().mu()/rho_;
#else
const volScalarField& nufField = sm.turbulence().nu();
#endif
// Local variables
label cellI(-1);
vector drag(0,0,0);
vector Ufluid(0,0,0);
vector position(0,0,0);
scalar voidfraction(1);
vector Up(0,0,0);
vector Ur(0,0,0);
scalar ds(0);
scalar nuf(0);
scalar rhof(0);
vector WenYuDrag(0,0,0);
interpolationCellPoint<scalar> voidfractionInterpolator_(alpf_);
interpolationCellPoint<vector> UInterpolator_(Uf_);
//
//_AO_Parallel
DragForce_.resize(particleList_.size());
for(int ii =0; ii < particleList_.size(); ii++)
{
int index = particleList_[ii][0];
cellI = sm.cellIDs()[index][0];
drag = vector(0,0,0);
Ufluid = vector(0,0,0);
WenYuDrag = vector(0,0,0);
DragForce_[ii] = vector(0,0,0);
if (cellI > -1) // particle Found
{
position = sm.position(index);
if ( alpf_[cellI] > 1. ) Pout << " voidfraction > 1 " << alpf_[cellI] << endl;
voidfraction = voidfractionInterpolator_.interpolate(position,cellI);
Ufluid = UInterpolator_.interpolate(position,cellI);
if ( voidfraction > 1. )
{
Pout << " Int. voidfraction > 1 " << " value= " << voidfraction;
voidfraction = alpf_[cellI];
Pout << " mod. value = " << voidfraction << endl;
}
Up = sm.velocity(index);
Ur = Ufluid-Up;
ds = 2*sm.radius(index);
rhof = rho_[cellI];
nuf = nufField[cellI];
// Drag force
WenYuDragForce(Ur,ds,rhof,nuf,voidfraction,WenYuDrag);
if(verbose_ && index <= 1)
{
Info << "" << endl;
Pout << " index = " << index << endl;
Pout << " position = " << position << endl;
Pout << " Up = " << Up << endl;
Pout << " Ur = " << Ur << endl;
Pout << " dp = " << ds << endl;
Pout << " rho = " << rhof << endl;
Pout << " nuf = " << nuf << endl;
Pout << " voidfraction = " << voidfraction << endl;
Pout << " drag = " << WenYuDrag << endl;
Info << " " << endl;
}
}
for(int j=0;j<3;j++) DragForce_[ii][j] = WenYuDrag[j];
}
}
// Construct from components
eulerianScalarField::eulerianScalarField
(
const dictionary& dict,
cfdemCloud& sm,
word modelType,
int modelID
)
:
dict_(dict),
particleCloud_(sm),
fieldName_(modelType),
cpVolumetricFieldName_(dict_.lookupOrDefault<word>("cpVolumetricFieldName", "na")),
cpVolumetric_(dict_.lookupOrDefault<scalar>("cpVolumetric", 0.0)),
updateMixtureProperties_(dict_.lookupOrDefault<bool>("updateMixtureProperties", false)),
rho_(dict_.lookupOrDefault<scalar>("rho"+fieldName_, -1)),
rhoCarrier_(dict_.lookupOrDefault<scalar>("rhoCarrier", -1)),
cp_(dict_.lookupOrDefault<scalar>("cp"+fieldName_, -1)),
cpCarrier_(dict_.lookupOrDefault<scalar>("cpCarrier", -1)),
m_
( IOobject
(
fieldName_,
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh()
),
mSource_
( IOobject
(
fieldName_+"Source",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh()
),
mSourceKImpl_
( IOobject
(
fieldName_+"SourceKImpl",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
0.0*mSource_ /( m_ + dimensionedScalar("dummy", m_.dimensions(), 1e-32) ) //initi with zero
),
fieldType_("undefined")
#ifndef versionExt32
,fvOptions_(sm.mesh())
#endif
{
if ( m_.dimensions() == dimensionSet(0, 0, 0, 1, 0) )
{
speciesID_ = -1;
fieldType_ = "temperature";
Info << "eulerianScalarField:: found a Temperature field! " << endl;
}
else
{
speciesID_ = modelID;
fieldType_ = "species";
Info << "eulerianScalarField:: found a species field, will assign speciesID: "
<< speciesID_
<< endl;
}
#ifndef versionExt32
fvOptions_.reset(dict.subDict("fvOptions"+fieldName_));
#endif
if( (cpVolumetricFieldName_=="na"||!updateMixtureProperties_) && cpVolumetric_<=0.0)
FatalError <<"You did not specify a cpVolumetricFieldName (or you do not updateMixtureProperties) and also cpVolumetric is zero (or negative)! Either provide the field name, or set cpVolumetric to a reasonable value. \n"
<< abort(FatalError);
if(speciesID_>-1 && updateMixtureProperties_ && (rho_<=0 || cp_<=0) )
FatalError <<"You like to update the phase properties, but density and cp of the eulerianScalarField with name '"
<< fieldName_
<<"' are not specified or zero. \n"
<< abort(FatalError);
if(speciesID_>-1 && updateMixtureProperties_ && (rhoCarrier_<=0 || cpCarrier_<=0) )
FatalError <<"You like to update the phase properties, but density and cp of the carrier phase are not specified or zero \n"
<< abort(FatalError);
//Report options for cp
if(fieldType_=="temperature")
{
if(cpVolumetric_!=0.0 && cpVolumetricFieldName_!="na")
FatalError <<"eulerianScalarField:: You have specified 'cpVolumetric' and 'cpVolumetricFieldName' in a dictionary in '/constant'. This might be confusing. Please unset one of these two inputs to avoid confusion. \n"
<< abort(FatalError);
if(cpVolumetricFieldName_=="na" || !updateMixtureProperties_) //use also if mixture properties are not updated
Info << "eulerianScalarField:: will use the following FIXED VOLUMETRIC HEAT CAPACITY: "
<< cpVolumetric_ << " [J/K/m³]" << endl;
else
Info << "eulerianScalarField:: will use the a SPATIALLY-VARAIBLE VOLUMETRIC HEAT CAPACITY with name: " << cpVolumetricFieldName_ << endl;
}
}
// ***********************************************************
// Construct from components for scalarGeneralExchangePhaseChange
scalarGeneralExchange::scalarGeneralExchange
(
const dictionary& dict,
cfdemCloud& sm,
word dictName
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(dictName + "Props")),
scalarTransportProperties_ //this is clumsy, but effective
(
IOobject
(
"scalarTransportProperties",
sm.mesh().time().constant(),
sm.mesh(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
generalPropsDict_(scalarTransportProperties_.subDict("generalManualProps")),
voidfractionFieldName_(propsDict_.lookup("voidfractionFieldName")), //common names/data
velFieldName_(propsDict_.lookup("velFieldName")),
tempFieldName_(propsDict_.lookup("tempFieldName")), //temperature names/data
partTempName_(propsDict_.lookup("partTempName")),
partHeatFluxName_(propsDict_.lookupOrDefault<word>( "partHeatFluxName", "none")),
partHeatTransCoeffName_(propsDict_.lookupOrDefault<word>("partHeatTransCoeffName", "none")),
partHeatFluidName_(propsDict_.lookupOrDefault<word>( "partHeatFluidName", "none")),
partDat_(NULL),
partDatFlux_(NULL),
partDatTransCoeff_(NULL),
partDatFluid_(NULL),
partDatTmpExpl_(NULL),
partDatTmpImpl_(NULL),
validPartFlux_(false),
validPartTransCoeff_(false),
validPartFluid_(false),
haveTemperatureEqn_(false),
useLiMason_(false),
useGeneralCorrelation_(false),
lambda_(readScalar(propsDict_.lookup("lambda"))),
Prandtl_(readScalar(propsDict_.lookup("Prandtl"))),
eulerianFieldNames_( generalPropsDict_.lookup("eulerianFields")),
partSpeciesNames_(propsDict_.lookup("partSpeciesNames")),
partSpeciesFluxNames_(propsDict_.lookup("partSpeciesFluxNames")),
partSpeciesTransCoeffNames_(propsDict_.lookup("partSpeciesTransCoeffNames")),
partSpeciesFluidNames_(propsDict_.lookup("partSpeciesFluidNames")),
DMolecular_(propsDict_.lookup("DMolecular")),
partHeatFluxPositionInRegister_(-1),
partHeatTransCoeffPositionInRegister_(-1),
partHeatFluidPositionInRegister_(-1),
maxSource_(1e30),
scaleDia_(1.)
{
setForceSubModels(propsDict_);
setupModel();
if (probeIt_ && propsDict_.found("suppressProbe"))
probeIt_=!Switch(propsDict_.lookup("suppressProbe"));
if(probeIt_)
{
forAll(eulerianFieldNames_, fieldIt)
{
particleCloud_.probeM().initialize(dictName, dictName + "_" + eulerianFieldNames_[fieldIt] + ".logDat");
particleCloud_.probeM().vectorFields_.append("Urel"); //first entry must the be the vector to probe
if(eulerianFieldNames_[fieldIt]==tempFieldName_) //this is the temperature
{
particleCloud_.probeM().scalarFields_.append("Rep");
particleCloud_.probeM().scalarFields_.append("Nu"); //other are debug
}
else
particleCloud_.probeM().scalarFields_.append("Sh");
particleCloud_.probeM().scalarFields_.append("exchangeRate");
particleCloud_.probeM().writeHeader();
}
}
