void Foam::particle::readFields(CloudType& c)
{
if (!c.size())
{
return;
}
IOobject procIO(c.fieldIOobject("origProcId", IOobject::MUST_READ));
if (procIO.headerOk())
{
IOField<label> origProcId(procIO);
c.checkFieldIOobject(c, origProcId);
IOField<label> origId(c.fieldIOobject("origId", IOobject::MUST_READ));
c.checkFieldIOobject(c, origId);
label i = 0;
forAllIter(typename CloudType, c, iter)
{
particle& p = iter();
p.origProc_ = origProcId[i];
p.origId_ = origId[i];
i++;
}
}
Foam::ManualInjectionWet<CloudType>::ManualInjectionWet
(
const dictionary& dict,
CloudType& owner,
const word& modelName
)
:
InjectionModel<CloudType>(dict, owner, modelName, typeName),
positionsFile_(this->coeffDict().lookup("positionsFile")),
positions_
(
IOobject
(
positionsFile_,
owner.db().time().constant(),
owner.mesh(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
diameters_(positions_.size()),
injectorCells_(positions_.size(), -1),
injectorTetFaces_(positions_.size(), -1),
injectorTetPts_(positions_.size(), -1),
U0_(this->coeffDict().lookup("U0")),
sizeDistribution_
(
distributionModels::distributionModel::New
(
this->coeffDict().subDict("sizeDistribution"),
owner.rndGen()
)
),
ignoreOutOfBounds_
(
this->coeffDict().lookupOrDefault("ignoreOutOfBounds", false)
),
iniVliq_
(
readScalar
(
this->coeffDict().lookup("initialLiquidVolumePerParticle")
)
)
{
updateMesh();
// Construct parcel diameters
forAll(diameters_, i)
{
diameters_[i] = sizeDistribution_->sample();
}
// Determine volume of particles to inject
this->volumeTotal_ = sum(pow3(diameters_))*pi/6.0;
}
Foam::COxidationKineticDiffusionLimitedRate<CloudType>::
COxidationKineticDiffusionLimitedRate
(
const dictionary& dict,
CloudType& owner
)
:
SurfaceReactionModel<CloudType>(dict, owner, typeName),
Sb_(readScalar(this->coeffDict().lookup("Sb"))),
C1_(readScalar(this->coeffDict().lookup("C1"))),
C2_(readScalar(this->coeffDict().lookup("C2"))),
E_(readScalar(this->coeffDict().lookup("E"))),
CsLocalId_(-1),
O2GlobalId_(owner.composition().globalCarrierId("O2")),
CO2GlobalId_(owner.composition().globalCarrierId("CO2")),
WC_(0.0),
WO2_(0.0),
HcCO2_(0.0)
{
// Determine Cs ids
label idSolid = owner.composition().idSolid();
CsLocalId_ = owner.composition().localId(idSolid, "C");
// Set local copies of thermo properties
WO2_ = owner.thermo().carrier().W(O2GlobalId_);
const scalar WCO2 = owner.thermo().carrier().W(CO2GlobalId_);
WC_ = WCO2 - WO2_;
HcCO2_ = owner.thermo().carrier().Hc(CO2GlobalId_);
const scalar YCloc = owner.composition().Y0(idSolid)[CsLocalId_];
const scalar YSolidTot = owner.composition().YMixture0()[idSolid];
Info<< " C(s): particle mass fraction = " << YCloc*YSolidTot << endl;
}
NearestNeighbourSearch<T, CloudType>::NearestNeighbourSearch(const CloudType& cloud, const Index dim, const unsigned creationOptionFlags):
cloud(cloud),
dim(min(dim, int(cloud.rows()))),
creationOptionFlags(creationOptionFlags),
minBound(Vector::Constant(this->dim, numeric_limits<T>::max())),
maxBound(Vector::Constant(this->dim, numeric_limits<T>::min()))
{
if (cloud.cols() == 0)
throw runtime_error("Cloud has no points");
if (cloud.rows() == 0)
throw runtime_error("Cloud has 0 dimensions");
}
Foam::InjectionModel<CloudType>::InjectionModel
(
const dictionary& dict,
CloudType& owner,
const word& type
)
:
dict_(dict),
owner_(owner),
coeffDict_(dict.subDict(type + "Coeffs")),
SOI_(readScalar(coeffDict_.lookup("SOI"))),
volumeTotal_(0.0),
massTotal_(dimensionedScalar(coeffDict_.lookup("massTotal")).value()),
massInjected_(0.0),
nInjections_(0),
parcelsAddedTotal_(0),
parcelBasis_(pbNumber),
time0_(owner.db().time().value()),
timeStep0_(0.0)
{
// Provide some info
// - also serves to initialise mesh dimensions - needed for parallel runs
// due to lazy evaluation of valid mesh dimensions
Info<< " Constructing " << owner.mesh().nGeometricD() << "-D injection"
<< endl;
word parcelBasisType = coeffDict_.lookup("parcelBasisType");
if (parcelBasisType == "mass")
{
parcelBasis_ = pbMass;
}
else if (parcelBasisType == "number")
{
parcelBasis_ = pbNumber;
}
else
{
FatalErrorIn
(
"Foam::InjectionModel<CloudType>::InjectionModel"
"("
"const dictionary&, "
"CloudType&, "
"const word&"
")"
)<< "parcelBasisType must be either 'number' or 'mass'" << nl
<< exit(FatalError);
}
readProps();
}
Foam::ReactingMultiphaseLookupTableInjection<CloudType>::
ReactingMultiphaseLookupTableInjection
(
const dictionary& dict,
CloudType& owner,
const word& modelName
)
:
InjectionModel<CloudType>(dict, owner, modelName, typeName),
inputFileName_(this->coeffDict().lookup("inputFile")),
duration_(readScalar(this->coeffDict().lookup("duration"))),
parcelsPerSecond_
(
readScalar(this->coeffDict().lookup("parcelsPerSecond"))
),
injectors_
(
IOobject
(
inputFileName_,
owner.db().time().constant(),
owner.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
injectorCells_(0),
injectorTetFaces_(0),
injectorTetPts_(0)
{
duration_ = owner.db().time().userTimeToTime(duration_);
// Set/cache the injector cells
injectorCells_.setSize(injectors_.size());
injectorTetFaces_.setSize(injectors_.size());
injectorTetPts_.setSize(injectors_.size());
updateMesh();
// Determine volume of particles to inject
this->volumeTotal_ = 0.0;
forAll(injectors_, i)
{
this->volumeTotal_ += injectors_[i].mDot()/injectors_[i].rho();
}
this->volumeTotal_ *= duration_;
}
Foam::SingleKineticRateDevolatilisation<CloudType>::
SingleKineticRateDevolatilisation
(
const dictionary& dict,
CloudType& owner
)
:
DevolatilisationModel<CloudType>(dict, owner, typeName),
volatileData_(this->coeffDict().lookup("volatileData")),
YVolatile0_(volatileData_.size()),
volatileToGasMap_(volatileData_.size()),
residualCoeff_(readScalar(this->coeffDict().lookup("residualCoeff")))
{
if (volatileData_.empty())
{
WarningIn
(
"Foam::SingleKineticRateDevolatilisation<CloudType>::"
"SingleKineticRateDevolatilisation"
"("
"const dictionary& dict, "
"CloudType& owner"
")"
) << "Devolatilisation model selected, but no volatiles defined"
<< nl << endl;
}
else
{
Info<< "Participating volatile species:" << endl;
// Determine mapping between active volatiles and cloud gas components
const label idGas = owner.composition().idGas();
const scalar YGasTot = owner.composition().YMixture0()[idGas];
const scalarField& YGas = owner.composition().Y0(idGas);
forAll(volatileData_, i)
{
const word& specieName = volatileData_[i].name();
const label id = owner.composition().localId(idGas, specieName);
volatileToGasMap_[i] = id;
YVolatile0_[i] = YGasTot*YGas[id];
Info<< " " << specieName << ": particle mass fraction = "
<< YVolatile0_[i] << endl;
}
}
}
Foam::ThermoLookupTableInjection<CloudType>::ThermoLookupTableInjection
(
const dictionary& dict,
CloudType& owner
)
:
InjectionModel<CloudType>(dict, owner, typeName),
inputFileName_(this->coeffDict().lookup("inputFile")),
duration_(readScalar(this->coeffDict().lookup("duration"))),
parcelsPerSecond_
(
readScalar(this->coeffDict().lookup("parcelsPerSecond"))
),
injectors_
(
IOobject
(
inputFileName_,
owner.db().time().constant(),
owner.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
injectorCells_(0),
injectorTetFaces_(0),
injectorTetPts_(0)
{
duration_ = owner.db().time().userTimeToTime(duration_);
// Set/cache the injector cells
injectorCells_.setSize(injectors_.size());
injectorTetFaces_.setSize(injectors_.size());
injectorTetPts_.setSize(injectors_.size());
forAll(injectors_, i)
{
this->findCellAtPosition
(
injectorCells_[i],
injectorTetFaces_[i],
injectorTetPts_[i],
injectors_[i].x()
);
}
void Foam::TemplateCollidingParcel<ParcelType>::readFields(CloudType& c)
{
if (!c.size())
{
return;
}
ParcelType::readFields(c);
}
Foam::GravityForce<CloudType>::GravityForce
(
CloudType& owner,
const fvMesh& mesh,
const dictionary& dict
)
:
ParticleForce<CloudType>(owner, mesh, dict, typeName, false),
g_(owner.g().value())
{}
Foam::LiquidEvaporation<CloudType>::LiquidEvaporation
(
const dictionary& dict,
CloudType& owner
)
:
PhaseChangeModel<CloudType>(dict, owner, typeName),
liquids_
(
liquidMixture::New
(
owner.mesh().objectRegistry::template
lookupObject<dictionary>
(
owner.carrierThermo().name()
)
)
),
activeLiquids_(this->coeffDict().lookup("activeLiquids")),
liqToCarrierMap_(activeLiquids_.size(), -1),
liqToLiqMap_(activeLiquids_.size(), -1)
{
if (activeLiquids_.size() == 0)
{
WarningIn
(
"Foam::LiquidEvaporation<CloudType>::LiquidEvaporation"
"("
"const dictionary& dict, "
"CloudType& owner"
")"
) << "Evaporation model selected, but no active liquids defined"
<< nl << endl;
}
// Determine mapping between liquid and carrier phase species
forAll(activeLiquids_, i)
{
liqToCarrierMap_[i] =
owner.composition().globalCarrierId(activeLiquids_[i]);
}
Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel
(
const dictionary& dict,
CloudType& owner,
const word& type
)
:
SubModelBase<CloudType>(owner, dict, typeName, type),
g_(owner.g()),
ejectedParcelType_
(
this->coeffDict().lookupOrDefault("ejectedParcelType", -1)
),
massParcelPatch_(0),
diameterParcelPatch_(0),
UFilmPatch_(0),
rhoFilmPatch_(0),
deltaFilmPatch_(owner.mesh().boundary().size()),
nParcelsTransferred_(0),
nParcelsInjected_(0)
{}
Foam::ManualInjection<CloudType>::ManualInjection
(
const dictionary& dict,
CloudType& owner
)
:
InjectionModel<CloudType>(dict, owner, typeName),
positionsFile_(this->coeffDict().lookup("positionsFile")),
positions_
(
IOobject
(
positionsFile_,
owner.db().time().constant(),
owner.mesh(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
diameters_(positions_.size()),
U0_(this->coeffDict().lookup("U0")),
parcelPDF_
(
pdfs::pdf::New
(
this->coeffDict().subDict("parcelPDF"),
owner.rndGen()
)
)
{
// Construct parcel diameters
forAll(diameters_, i)
{
diameters_[i] = parcelPDF_->sample();
}
// Determine volume of particles to inject
this->volumeTotal_ = sum(pow3(diameters_))*mathematicalConstant::pi/6.0;
}
Foam::COxidationHurtMitchell<CloudType>::COxidationHurtMitchell
(
const dictionary& dict,
CloudType& owner
)
:
SurfaceReactionModel<CloudType>(dict, owner, typeName),
Sb_(readScalar(this->coeffDict().lookup("Sb"))),
CsLocalId_(-1),
ashLocalId_(-1),
O2GlobalId_(owner.composition().globalCarrierId("O2")),
CO2GlobalId_(owner.composition().globalCarrierId("CO2")),
WC_(0.0),
WO2_(0.0),
HcCO2_(0.0),
heatOfReaction_(-1.0)
{
// Determine Cs and ash ids
label idSolid = owner.composition().idSolid();
CsLocalId_ = owner.composition().localId(idSolid, "C");
ashLocalId_ = owner.composition().localId(idSolid, "ash", true);
// Set local copies of thermo properties
WO2_ = owner.thermo().carrier().W(O2GlobalId_);
const scalar WCO2 = owner.thermo().carrier().W(CO2GlobalId_);
WC_ = WCO2 - WO2_;
HcCO2_ = owner.thermo().carrier().Hc(CO2GlobalId_);
const scalar YCloc = owner.composition().Y0(idSolid)[CsLocalId_];
const scalar YSolidTot = owner.composition().YMixture0()[idSolid];
Info<< " C(s): particle mass fraction = " << YCloc*YSolidTot << endl;
if (this->coeffDict().readIfPresent("heatOfReaction", heatOfReaction_))
{
Info<< " Using user specified heat of reaction: "
<< heatOfReaction_ << " [J/kg]" << endl;
}
}
void Foam::WetParcel<ParcelType>::writeFields(const CloudType& c)
{
ParcelType::writeFields(c);
label np = c.size();
IOField<scalar> Vliq(c.fieldIOobject("Vliq", IOobject::NO_READ), np);
label i = 0;
forAllConstIter(typename CloudType, c, iter)
{
const WetParcel<ParcelType>& p = iter();
Vliq[i] = p.Vliq();
i++;
}
Vliq.write();
}
Foam::COxidationDiffusionLimitedRate<CloudType>::COxidationDiffusionLimitedRate
(
const dictionary& dict,
CloudType& owner
)
:
SurfaceReactionModel<CloudType>(dict, owner, typeName),
Sb_(readScalar(this->coeffDict().lookup("Sb"))),
D_(readScalar(this->coeffDict().lookup("D"))),
CsLocalId_(-1),
O2GlobalId_(owner.composition().carrierId("O2")),
CO2GlobalId_(owner.composition().carrierId("CO2")),
WC_(0.0),
WO2_(0.0),
HcCO2_(0.0)
{
// Determine Cs ids
label idSolid = owner.composition().idSolid();
CsLocalId_ = owner.composition().localId(idSolid, "C");
// Set local copies of thermo properties
WO2_ = owner.thermo().carrier().W(O2GlobalId_);
const scalar WCO2 = owner.thermo().carrier().W(CO2GlobalId_);
WC_ = WCO2 - WO2_;
HcCO2_ = owner.thermo().carrier().Hc(CO2GlobalId_);
if (Sb_ < 0)
{
FatalErrorIn
(
"COxidationDiffusionLimitedRate<CloudType>"
"("
"const dictionary&, "
"CloudType&"
")"
) << "Stoichiometry of reaction, Sb, must be greater than zero" << nl
<< exit(FatalError);
}
const scalar YCloc = owner.composition().Y0(idSolid)[CsLocalId_];
const scalar YSolidTot = owner.composition().YMixture0()[idSolid];
Info<< " C(s): particle mass fraction = " << YCloc*YSolidTot << endl;
}
Foam::CompositionModel<CloudType>::CompositionModel
(
const dictionary& dict,
CloudType& owner,
const word& type
)
:
dict_(dict),
owner_(owner),
coeffDict_(dict.subDict(type + "Coeffs")),
mcCarrierThermo_(owner.mcCarrierThermo()),
liquids_
(
liquidMixture::New
(
owner.mesh().objectRegistry::lookupObject<dictionary>
(
owner.carrierThermo().name()
)
)
),
solids_
(
solidMixture::New
(
owner.mesh().objectRegistry::lookupObject<dictionary>
(
owner.carrierThermo().name()
)
)
),
phaseProps_
(
coeffDict_.lookup("phases"),
mcCarrierThermo_.species(),
liquids_().components(),
solids_().components()
)
{}
Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel(CloudType& owner)
:
SubModelBase<CloudType>(owner),
g_(owner.g()),
ejectedParcelType_(0),
massParcelPatch_(0),
diameterParcelPatch_(0),
UFilmPatch_(0),
rhoFilmPatch_(0),
deltaFilmPatch_(0),
nParcelsTransferred_(0),
nParcelsInjected_(0)
{}
Foam::LocalInteraction<CloudType>::LocalInteraction
(
const dictionary& dict,
CloudType& cloud
)
:
PatchInteractionModel<CloudType>(dict, cloud, typeName),
patchData_(cloud.mesh(), this->coeffDict()),
nEscape_(patchData_.size(), 0),
massEscape_(patchData_.size(), 0.0),
nStick_(patchData_.size(), 0),
massStick_(patchData_.size(), 0.0),
writeFields_(this->coeffDict().lookupOrDefault("writeFields", false)),
massEscapePtr_(NULL),
massStickPtr_(NULL)
{
if (writeFields_)
{
word massEscapeName(this->owner().name() + ":massEscape");
word massStickName(this->owner().name() + ":massStick");
Info<< " Interaction fields will be written to " << massEscapeName
<< " and " << massStickName << endl;
(void)massEscape();
(void)massStick();
}
else
{
Info<< " Interaction fields will not be written" << endl;
}
// check that interactions are valid/specified
forAll(patchData_, patchI)
{
const word& interactionTypeName =
patchData_[patchI].interactionTypeName();
const typename PatchInteractionModel<CloudType>::interactionType& it =
this->wordToInteractionType(interactionTypeName);
if (it == PatchInteractionModel<CloudType>::itOther)
{
const word& patchName = patchData_[patchI].patchName();
FatalErrorIn("LocalInteraction(const dictionary&, CloudType&)")
<< "Unknown patch interaction type "
<< interactionTypeName << " for patch " << patchName
<< ". Valid selections are:"
<< this->PatchInteractionModel<CloudType>::interactionTypeNames_
<< nl << exit(FatalError);
}
}
}
Foam::BrownianMotionForce<CloudType>::BrownianMotionForce
(
CloudType& owner,
const fvMesh& mesh,
const dictionary& dict
)
:
ParticleForce<CloudType>(owner, mesh, dict, typeName, true),
rndGen_(owner.rndGen()),
lambda_(readScalar(this->coeffs().lookup("lambda"))),
turbulence_(readBool(this->coeffs().lookup("turbulence"))),
kPtr_(NULL),
ownK_(false)
{}
void Foam::WetParcel<ParcelType>::readFields(CloudType& c)
{
if (!c.size())
{
return;
}
ParcelType::readFields(c);
IOField<scalar> Vliq(c.fieldIOobject("Vliq", IOobject::MUST_READ));
c.checkFieldIOobject(c, Vliq);
label i = 0;
forAllIter(typename CloudType, c, iter)
{
WetParcel<ParcelType>& p = iter();
p.Vliq_ = Vliq[i];
i++;
}
}
Foam::CloudFunctionObject<CloudType>::CloudFunctionObject
(
const dictionary& dict,
CloudType& owner,
const word& modelName,
const word& objectType
)
:
SubModelBase<CloudType>(modelName, owner, dict, typeName, objectType),
outputDir_(owner.mesh().time().path())
{
if (Pstream::parRun())
{
// Put in undecomposed case (Note: gives problems for
// distributed data running)
outputDir_ =
outputDir_/".."/"postProcessing"/cloud::prefix/owner.name()/this->modelName();
}
else
{
outputDir_ =
outputDir_/"postProcessing"/cloud::prefix/owner.name()/this->modelName();
}
}
Foam::CompositionModel<CloudType>::CompositionModel
(
const dictionary& dict,
CloudType& owner,
const word& type
)
:
SubModelBase<CloudType>(owner, dict, typeName, type),
thermo_(owner.thermo()),
phaseProps_
(
this->coeffDict().lookup("phases"),
thermo_.carrier().species(),
thermo_.liquids().components(),
thermo_.solids().components()
)
{}
Foam::DispersionRASModel<CloudType>::DispersionRASModel
(
const dictionary& dict,
CloudType& owner
)
:
DispersionModel<CloudType>(dict, owner),
turbulence_
(
owner.mesh().objectRegistry::lookupObject<compressible::RASModel>
(
"RASProperties"
)
),
kPtr_(NULL),
ownK_(false),
epsilonPtr_(NULL),
ownEpsilon_(false)
{}
Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel
(
const dictionary& dict,
CloudType& owner,
const dimensionedVector& g,
const word& type
)
:
dict_(dict),
owner_(owner),
g_(g),
coeffDict_(dict.subDict(type + "Coeffs")),
ejectedParcelType_(coeffDict_.lookupOrDefault("ejectedParcelType", -1)),
injectorCellsPatch_(0),
massParcelPatch_(0),
diameterParcelPatch_(0),
UFilmPatch_(0),
rhoFilmPatch_(0),
deltaFilmPatch_(owner.mesh().boundary().size()),
nParcelsTransferred_(0),
nParcelsInjected_(0)
{}
void Foam::WetParcel<ParcelType>::writeFields(const CloudType& c)
{
ParcelType::writeFields(c);
label np = c.size();
IOField<scalar> Vliq(c.fieldIOobject("Vliq", IOobject::NO_READ), np);
IOField<scalarField> partVliq(c.fieldIOobject("partVliq", IOobject::NO_READ), np);
IOField<vectorField> liquidPositions(c.fieldIOobject("liquidPositions", IOobject::NO_READ), np);
IOField<vectorField> liquidPositionVectors(c.fieldIOobject("liquidPositionVectors", IOobject::NO_READ), np);
IOField<labelField> contactList(c.fieldIOobject("contactList", IOobject::NO_READ), np);
IOField<labelField> previousContactList(c.fieldIOobject("previousContactList", IOobject::NO_READ), np);
label i = 0;
forAllConstIter(typename CloudType, c, iter)
{
const WetParcel<ParcelType>& p = iter();
Vliq[i] = p.Vliq();
partVliq[i] = p.partVliq();
liquidPositions[i] = p.liquidPositions();
liquidPositionVectors[i] = p.liquidPositionVectors();
contactList[i] = p.contactList();
previousContactList[i] = p.previousContactList();
i++;
}
Vliq.write();
partVliq.write();
liquidPositions.write();
liquidPositionVectors.write();
contactList.write();
previousContactList.write();
}
Foam::FieldActivatedInjection<CloudType>::FieldActivatedInjection
(
const dictionary& dict,
CloudType& owner,
const word& modelName
)
:
InjectionModel<CloudType>(dict, owner, modelName, typeName),
factor_(readScalar(this->coeffDict().lookup("factor"))),
referenceField_
(
owner.db().objectRegistry::template lookupObject<volScalarField>
(
this->coeffDict().lookup("referenceField")
)
),
thresholdField_
(
owner.db().objectRegistry::template lookupObject<volScalarField>
(
this->coeffDict().lookup("thresholdField")
)
),
positionsFile_(this->coeffDict().lookup("positionsFile")),
positions_
(
IOobject
(
positionsFile_,
owner.db().time().constant(),
owner.mesh(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
injectorCells_(positions_.size()),
injectorTetFaces_(positions_.size()),
injectorTetPts_(positions_.size()),
nParcelsPerInjector_
(
readLabel(this->coeffDict().lookup("parcelsPerInjector"))
),
nParcelsInjected_(positions_.size(), 0),
U0_(this->coeffDict().lookup("U0")),
diameters_(positions_.size()),
sizeDistribution_
(
distributionModels::distributionModel::New
(
this->coeffDict().subDict("sizeDistribution"),
owner.rndGen()
)
)
{
// Construct parcel diameters - one per injector cell
forAll(diameters_, i)
{
diameters_[i] = sizeDistribution_->sample();
}
// Determine total volume of particles to inject
this->volumeTotal_ =
nParcelsPerInjector_*sum(pow3(diameters_))*pi/6.0;
updateMesh();
}
Foam::SwakScriptableInjection<CloudType>::SwakScriptableInjection
(
const dictionary& dict,
CloudType& owner
#ifdef FOAM_INJECT_CONSTRUCTOR_HAS_MODELNAME
,const word& modelName
#endif
)
:
InjectionModel<CloudType>(
dict, owner, typeName
#ifdef FOAM_INJECT_CONSTRUCTOR_HAS_MODELNAME
,modelName
#endif
),
interpreter_(
generalInterpreterWrapper::New(
owner.mesh(),
this->coeffDict()
)
),
parameterStructName_(
this->coeffDict().lookup("parameterStructName")
),
resultStructName_(
this->coeffDict().lookup("resultStructName")
),
injectByEvent_(
readBool(
this->coeffDict().lookup("injectByEvent")
)
),
isActive_(false),
plannedDuration_(1e10)
{
interpreter().readCode(
this->coeffDict(),
"initInjector",
initInjectorCode_
);
if(injectByEvent_) {
interpreter().readCode(
this->coeffDict(),
"doStartInjection",
doStartInjectionCode_
);
interpreter().readCode(
this->coeffDict(),
"doStopInjection",
doStopInjectionCode_
);
} else {
interpreter().readCode(
this->coeffDict(),
"injectionDuration",
injectionDurationCode_
);
interpreter().readCode(
this->coeffDict(),
"startOfInjectionTime",
startOfInjectionTimeCode_
);
}
interpreter().readCode(
this->coeffDict(),
"parcelsToInject",
parcelsToInjectCode_
);
interpreter().readCode(
this->coeffDict(),
"volumeToInject",
volumeToInjectCode_
);
interpreter().readCode(
this->coeffDict(),
"prepareParcelData",
prepareParcelDataCode_
);
interpreter().readCode(
this->coeffDict(),
"particleProperties",
particlePropertiesCode_
);
Info << "Executing initialization code for "
<< this->owner().name() << endl;
interpreter().executeCode(
initInjectorCode_,
true // set global variables if necessary
);
}
Foam::ConeInjection<CloudType>::ConeInjection
(
const dictionary& dict,
CloudType& owner
)
:
InjectionModel<CloudType>(dict, owner, typeName),
duration_(readScalar(this->coeffDict().lookup("duration"))),
position_(this->coeffDict().lookup("position")),
injectorCell_(-1),
direction_(this->coeffDict().lookup("direction")),
parcelsPerSecond_
(
readScalar(this->coeffDict().lookup("parcelsPerSecond"))
),
volumeFlowRate_
(
DataEntry<scalar>::New
(
"volumeFlowRate",
this->coeffDict()
)
),
Umag_
(
DataEntry<scalar>::New
(
"Umag",
this->coeffDict()
)
),
thetaInner_
(
DataEntry<scalar>::New
(
"thetaInner",
this->coeffDict()
)
),
thetaOuter_
(
DataEntry<scalar>::New
(
"thetaOuter",
this->coeffDict()
)
),
parcelPDF_
(
pdf::New
(
this->coeffDict().subDict("parcelPDF"),
owner.rndGen()
)
),
tanVec1_(vector::zero),
tanVec2_(vector::zero)
{
// Normalise direction vector
direction_ /= mag(direction_);
// Determine direction vectors tangential to direction
vector tangent = vector::zero;
scalar magTangent = 0.0;
while (magTangent < SMALL)
{
vector v = this->owner().rndGen().vector01();
tangent = v - (v & direction_)*direction_;
magTangent = mag(tangent);
}
tanVec1_ = tangent/magTangent;
tanVec2_ = direction_^tanVec1_;
// Set total volume to inject
this->volumeTotal_ = volumeFlowRate_().integrate(0.0, duration_);
// Set/cache the injector cell
this->findCellAtPosition(injectorCell_, position_);
}
Foam::WallLocalSpringSliderDashpot<CloudType>::WallLocalSpringSliderDashpot
(
const dictionary& dict,
CloudType& cloud
)
:
WallModel<CloudType>(dict, cloud, typeName),
Estar_(),
Gstar_(),
alpha_(),
b_(),
mu_(),
patchMap_(),
maxEstarIndex_(-1),
collisionResolutionSteps_
(
readScalar
(
this->coeffDict().lookup("collisionResolutionSteps")
)
),
volumeFactor_(1.0),
useEquivalentSize_(Switch(this->coeffDict().lookup("useEquivalentSize")))
{
if (useEquivalentSize_)
{
volumeFactor_ = readScalar(this->coeffDict().lookup("volumeFactor"));
}
scalar pNu = this->owner().constProps().poissonsRatio();
scalar pE = this->owner().constProps().youngsModulus();
const polyMesh& mesh = cloud.mesh();
const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
patchMap_.setSize(bMesh.size(), -1);
DynamicList<label> wallPatchIndices;
forAll(bMesh, patchI)
{
if (isA<wallPolyPatch>(bMesh[patchI]))
{
wallPatchIndices.append(bMesh[patchI].index());
}
}
label nWallPatches = wallPatchIndices.size();
Estar_.setSize(nWallPatches);
Gstar_.setSize(nWallPatches);
alpha_.setSize(nWallPatches);
b_.setSize(nWallPatches);
mu_.setSize(nWallPatches);
scalar maxEstar = -GREAT;
forAll(wallPatchIndices, wPI)
{
const dictionary& patchCoeffDict
(
this->coeffDict().subDict(bMesh[wallPatchIndices[wPI]].name())
);
patchMap_[wallPatchIndices[wPI]] = wPI;
scalar nu = readScalar(patchCoeffDict.lookup("poissonsRatio"));
scalar E = readScalar(patchCoeffDict.lookup("youngsModulus"));
Estar_[wPI] = 1/((1 - sqr(pNu))/pE + (1 - sqr(nu))/E);
Gstar_[wPI] = 1/(2*((2 + pNu - sqr(pNu))/pE + (2 + nu - sqr(nu))/E));
alpha_[wPI] = readScalar(patchCoeffDict.lookup("alpha"));
b_[wPI] = readScalar(patchCoeffDict.lookup("b"));
mu_[wPI] = readScalar(patchCoeffDict.lookup("mu"));
if (Estar_[wPI] > maxEstar)
{
maxEstarIndex_ = wPI;
maxEstar = Estar_[wPI];
}
}
}
