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] ); }