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::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)
{}
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::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::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::ConeInjection<CloudType>::ConeInjection
(
const dictionary& dict,
CloudType& owner,
const word& modelName
)
:
InjectionModel<CloudType>(dict, owner, modelName, typeName),
positionAxis_(this->coeffDict().lookup("positionAxis")),
injectorCells_(positionAxis_.size()),
injectorTetFaces_(positionAxis_.size()),
injectorTetPts_(positionAxis_.size()),
duration_(readScalar(this->coeffDict().lookup("duration"))),
parcelsPerInjector_
(
readScalar(this->coeffDict().lookup("parcelsPerInjector"))
),
flowRateProfile_
(
TimeDataEntry<scalar>
(
owner.db().time(),
"flowRateProfile",
this->coeffDict()
)
),
Umag_
(
TimeDataEntry<scalar>
(
owner.db().time(),
"Umag",
this->coeffDict()
)
),
thetaInner_
(
TimeDataEntry<scalar>
(
owner.db().time(),
"thetaInner",
this->coeffDict()
)
),
thetaOuter_
(
TimeDataEntry<scalar>
(
owner.db().time(),
"thetaOuter",
this->coeffDict()
)
),
sizeDistribution_
(
distributionModels::distributionModel::New
(
this->coeffDict().subDict("sizeDistribution"), owner.rndGen()
)
),
nInjected_(this->parcelsAddedTotal()),
tanVec1_(positionAxis_.size()),
tanVec2_(positionAxis_.size())
{
duration_ = owner.db().time().userTimeToTime(duration_);
// Normalise direction vector and determine direction vectors
// tangential to injector axis direction
forAll(positionAxis_, i)
{
vector& axis = positionAxis_[i].second();
axis /= mag(axis);
vector tangent = vector::zero;
scalar magTangent = 0.0;
cachedRandom& rnd = this->owner().rndGen();
while (magTangent < SMALL)
{
vector v = rnd.sample01<vector>();
tangent = v - (v & axis)*axis;
magTangent = mag(tangent);
}
tanVec1_[i] = tangent/magTangent;
tanVec2_[i] = axis^tanVec1_[i];
}
Foam::InflationInjection<CloudType>::InflationInjection
(
const dictionary& dict,
CloudType& owner,
const word& modelName
)
:
InjectionModel<CloudType>(dict, owner, modelName, typeName),
generationSetName_(this->coeffDict().lookup("generationCellSet")),
inflationSetName_(this->coeffDict().lookup("inflationCellSet")),
generationCells_(),
inflationCells_(),
duration_(readScalar(this->coeffDict().lookup("duration"))),
flowRateProfile_
(
TimeFunction1<scalar>
(
owner.db().time(),
"flowRateProfile",
this->coeffDict()
)
),
growthRate_
(
TimeFunction1<scalar>
(
owner.db().time(),
"growthRate",
this->coeffDict()
)
),
newParticles_(),
volumeAccumulator_(0.0),
fraction_(1.0),
selfSeed_(this->coeffDict().lookupOrDefault("selfSeed", false)),
dSeed_(small),
sizeDistribution_
(
distributionModel::New
(
this->coeffDict().subDict("sizeDistribution"),
owner.rndGen()
)
)
{
duration_ = owner.db().time().userTimeToTime(duration_);
if (selfSeed_)
{
dSeed_ = readScalar(this->coeffDict().lookup("dSeed"));
}
cellSet generationCells(this->owner().mesh(), generationSetName_);
generationCells_ = generationCells.toc();
cellSet inflationCells(this->owner().mesh(), inflationSetName_);
// Union of cellSets
inflationCells |= generationCells;
inflationCells_ = inflationCells.toc();
if (Pstream::parRun())
{
scalar generationVolume = 0.0;
forAll(generationCells_, gCI)
{
label cI = generationCells_[gCI];
generationVolume += this->owner().mesh().cellVolumes()[cI];
}
scalar totalGenerationVolume = generationVolume;
reduce(totalGenerationVolume, sumOp<scalar>());
fraction_ = generationVolume/totalGenerationVolume;
}
Foam::PatchInjection<CloudType>::PatchInjection
(
const dictionary& dict,
CloudType& owner
)
:
InjectionModel<CloudType>(dict, owner, typeName),
patchName_(this->coeffDict().lookup("patchName")),
duration_(readScalar(this->coeffDict().lookup("duration"))),
parcelsPerSecond_
(
readScalar(this->coeffDict().lookup("parcelsPerSecond"))
),
U0_(this->coeffDict().lookup("U0")),
volumeFlowRate_
(
DataEntry<scalar>::New
(
"volumeFlowRate",
this->coeffDict()
)
),
parcelPDF_
(
pdfs::pdf::New
(
this->coeffDict().subDict("parcelPDF"),
owner.rndGen()
)
),
cellOwners_(),
fraction_(1.0)
{
label patchId = owner.mesh().boundaryMesh().findPatchID(patchName_);
if (patchId < 0)
{
FatalErrorIn
(
"PatchInjection<CloudType>::PatchInjection"
"("
"const dictionary&, "
"CloudType&"
")"
) << "Requested patch " << patchName_ << " not found" << nl
<< "Available patches are: " << owner.mesh().boundaryMesh().names()
<< nl << exit(FatalError);
}
const polyPatch& patch = owner.mesh().boundaryMesh()[patchId];
cellOwners_ = patch.faceCells();
label patchSize = cellOwners_.size();
label totalPatchSize = patchSize;
reduce(totalPatchSize, sumOp<label>());
fraction_ = scalar(patchSize)/totalPatchSize;
// Set total volume/mass to inject
this->volumeTotal_ = fraction_*volumeFlowRate_().integrate(0.0, duration_);
this->massTotal_ *= fraction_;
}
Foam::ConeInjectionMP<CloudType>::ConeInjectionMP
(
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
)
),
injectorCells_(positions_.size()),
axesFile_(this->coeffDict().lookup("axesFile")),
axes_
(
IOobject
(
axesFile_,
owner.db().time().constant(),
owner.mesh(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
duration_(readScalar(this->coeffDict().lookup("duration"))),
parcelsPerInjector_
(
readScalar(this->coeffDict().lookup("parcelsPerInjector"))
),
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_
(
pdfs::pdf::New
(
this->coeffDict().subDict("parcelPDF"),
owner.rndGen()
)
),
nInjected_(this->parcelsAddedTotal()),
tanVec1_(positions_.size()),
tanVec2_(positions_.size())
{
// Normalise direction vector and determine direction vectors
// tangential to direction
forAll(axes_, i)
{
axes_[i] /= mag(axes_[i]);
vector tangent = vector::zero;
scalar magTangent = 0.0;
while (magTangent < SMALL)
{
vector v = this->owner().rndGen().vector01();
tangent = v - (v & axes_[i])*axes_[i];
magTangent = mag(tangent);
}
tanVec1_[i] = tangent/magTangent;
tanVec2_[i] = axes_[i]^tanVec1_[i];
}
Foam::FieldActivatedInjection<CloudType>::FieldActivatedInjection
(
const dictionary& dict,
CloudType& owner
)
:
InjectionModel<CloudType>(dict, owner, typeName),
factor_(readScalar(this->coeffDict().lookup("factor"))),
referenceField_
(
owner.db().objectRegistry::lookupObject<volScalarField>
(
this->coeffDict().lookup("referenceField")
)
),
thresholdField_
(
owner.db().objectRegistry::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()),
nParcelsPerInjector_
(
readLabel(this->coeffDict().lookup("parcelsPerInjector"))
),
nParcelsInjected_(positions_.size(), 0),
U0_(this->coeffDict().lookup("U0")),
diameters_(positions_.size()),
parcelPDF_
(
pdfs::pdf::New
(
this->coeffDict().subDict("parcelPDF"),
owner.rndGen()
)
)
{
// Construct parcel diameters - one per injector cell
forAll(diameters_, i)
{
diameters_[i] = parcelPDF_->sample();
}
// Determine total volume of particles to inject
this->volumeTotal_ =
nParcelsPerInjector_*sum(pow3(diameters_))*mathematicalConstant::pi/6.0;
// Set/cache the injector cells
forAll(positions_, i)
{
this->findCellAtPosition
(
injectorCells_[i],
positions_[i]
);
}
