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