// 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
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);
}
// 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
noDrag::noDrag
(
const dictionary& dict,
cfdemCloud& sm
)
:
forceModel(dict,sm),
propsDict_(dict.subDict(typeName + "Props")),
noDEMForce_(propsDict_.lookupOrDefault("noDEMForce",false)),
keepCFDForce_(propsDict_.lookupOrDefault("keepCFDForce",false))
{
// init force sub model
setForceSubModels(propsDict_);
// define switches which can be read from dict
forceSubM(0).setSwitchesList(3,true); // activate search for verbose switch
// read those switches defined above, if provided in dict
forceSubM(0).readSwitches();
particleCloud_.checkCG(true);
}
// 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
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 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();
}
}
