Foam::turbulenceModel::turbulenceModel ( const volVectorField& U, const surfaceScalarField& alphaRhoPhi, const surfaceScalarField& phi, const word& propertiesName ) : IOdictionary ( IOobject ( IOobject::groupName(propertiesName, U.group()), U.time().constant(), U.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE ) ), runTime_(U.time()), mesh_(U.mesh()), U_(U), alphaRhoPhi_(alphaRhoPhi), phi_(phi), y_(mesh_) {}
turbulenceModel::turbulenceModel ( const volVectorField& U, const surfaceScalarField& phi, transportModel& transport, const word& turbulenceModelName ) : regIOobject ( IOobject ( turbulenceModelName, U.time().constant(), U.db(), IOobject::NO_READ, IOobject::NO_WRITE ) ), runTime_(U.time()), mesh_(U.mesh()), U_(U), phi_(phi), transportModel_(transport), y_(mesh_) {}
// Construct from components IncompressibleCloud::IncompressibleCloud( const volPointInterpolation& vpi, const volVectorField& U ) : Cloud<HardBallParticle>(U.mesh()), runTime_(U.time()), time0_(runTime_.value()), mesh_(U.mesh()), volPointInterpolation_(vpi), U_(U), smoment_(mesh_.nCells(), vector::zero), random(666), cloudProperties_ ( IOobject ( "cloudProperties", U.time().constant(), U.db(), IOobject::MUST_READ, IOobject::NO_WRITE ) ), interpolationSchemes_(cloudProperties_.subDict("interpolationSchemes")) { g_=cloudProperties_.lookup("g"); HardBallParticle::density=readScalar(cloudProperties_.lookup("density")); dragCoefficient_=readScalar(cloudProperties_.lookup("drag")); subCycles_=readScalar(cloudProperties_.lookup("subCycles")); useSourceMoment=readBool(cloudProperties_.lookup("useMomentumSource")); dictionary injection(cloudProperties_.subDict("injection")); thres=readScalar(injection.lookup("thres")); center=injection.lookup("center"); r0=readScalar(injection.lookup("r0")); vel0=readScalar(injection.lookup("vel0")); vel1=injection.lookup("vel1"); d0=readScalar(injection.lookup("d0")); d1=readScalar(injection.lookup("d1")); tStart=readScalar(injection.lookup("tStart")); tEnd=readScalar(injection.lookup("tEnd")); dictionary wall(cloudProperties_.subDict("wall")); wallReflect_=readBool(wall.lookup("reflect")); if(wallReflect_) { wallElasticity_=readScalar(wall.lookup("elasticity")); } }
LESModel::LESModel ( const word& type, const volVectorField& U, const surfaceScalarField& phi, transportModel& transport, const word& turbulenceModelName ) : turbulenceModel(U, phi, transport, turbulenceModelName), IOdictionary ( IOobject ( "LESProperties", U.time().constant(), U.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE ) ), printCoeffs_(lookupOrDefault<Switch>("printCoeffs", false)), coeffDict_(subOrEmptyDict(type + "Coeffs")), kMin_("kMin", sqr(dimVelocity), SMALL), delta_(LESdelta::New("delta", U.mesh(), *this)) { kMin_.readIfPresent(*this); // Force the construction of the mesh deltaCoeffs which may be needed // for the construction of the derived models and BCs mesh_.nonOrthDeltaCoeffs(); }
Foam::WhiteMetznerCross::WhiteMetznerCross ( const word& name, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), rho_(dict.lookup("rho")), etaS_(dict.lookup("etaS")), etaP_(dict.lookup("etaP")), lambda_(dict.lookup("lambda")), K_(dict.lookup("K")), L_(dict.lookup("L")), m_(dict.lookup("m")), n_(dict.lookup("n")) {}
// from components FENE_P::FENE_P ( const word& name, const volScalarField& alpha, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, alpha, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), etaS1_(dict.subDict("phase1").lookup("etaS")), etaS2_(dict.subDict("phase2").lookup("etaS")), etaP1_(dict.subDict("phase1").lookup("etaP")), etaP2_(dict.subDict("phase2").lookup("etaP")), lambda1_(dict.subDict("phase1").lookup("lambda")), lambda2_(dict.subDict("phase2").lookup("lambda")), Lquad1_(dict.subDict("phase1").lookup("Lquad")), Lquad2_(dict.subDict("phase2").lookup("Lquad")) {}
// from components Giesekus_Cross::Giesekus_Cross ( const word& name, const volScalarField& alpha, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : twoPhaseMixture(U, phi, "alpha"), viscoelasticLaw(name, alpha, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), etaS1_(dict.subDict("phase1").lookup("etaS")), etaS2_(dict.subDict("phase2").lookup("etaS")), etaP1_(dict.subDict("phase1").lookup("etaP")), etaP2_(dict.subDict("phase2").lookup("etaP")), lambda1_(dict.subDict("phase1").lookup("lambda")), lambda2_(dict.subDict("phase2").lookup("lambda")), alpha1_(dict.subDict("phase1").lookup("alpha")), alpha2_(dict.subDict("phase2").lookup("alpha")) {}
Foam::FENE_P::FENE_P ( const word& name, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), rho_(dict.lookup("rho")), etaS_(dict.lookup("etaS")), etaP_(dict.lookup("etaP")), L2_(dict.lookup("L2")), lambda_(dict.lookup("lambda")) {}
Foam::EPTT::EPTT ( const word& name, const volScalarField& alpha, const volScalarField& rho, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, alpha, rho, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), etaS1_(dict.subDict("phase1").lookup("etaS")), etaS2_(dict.subDict("phase2").lookup("etaS")), etaP1_(dict.subDict("phase1").lookup("etaP")), etaP2_(dict.subDict("phase2").lookup("etaP")), lambda1_(dict.subDict("phase1").lookup("lambda")), lambda2_(dict.subDict("phase2").lookup("lambda")), epsilon1_(dict.subDict("phase1").lookup("epsilon")), epsilon2_(dict.subDict("phase2").lookup("epsilon")), zeta1_(dict.subDict("phase1").lookup("zeta")), zeta2_(dict.subDict("phase2").lookup("zeta")) {}
Foam::autoPtr < Foam::TurbulenceModel<Alpha, Rho, BasicTurbulenceModel, TransportModel> > Foam::TurbulenceModel<Alpha, Rho, BasicTurbulenceModel, TransportModel>::New ( const alphaField& alpha, const rhoField& rho, const volVectorField& U, const surfaceScalarField& alphaRhoPhi, const surfaceScalarField& phi, const transportModel& transport, const word& propertiesName ) { // get model name, but do not register the dictionary // otherwise it is registered in the database twice const word modelType ( IOdictionary ( IOobject ( IOobject::groupName(propertiesName, U.group()), U.time().constant(), U.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false ) ).lookup("simulationType") ); Info<< "Selecting turbulence model type " << modelType << endl; typename dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(modelType); if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalErrorIn ( "TurbulenceModel::New" "(const alphaField&, const rhoField&, " "const volVectorField&, const surfaceScalarField&, " "transportModel&, const word&)" ) << "Unknown TurbulenceModel type " << modelType << nl << nl << "Valid TurbulenceModel types:" << endl << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError); } return autoPtr<TurbulenceModel> ( cstrIter()(alpha, rho, U, alphaRhoPhi, phi, transport, propertiesName) ); }
XPP_SE::XPP_SE ( const word& name, const volScalarField& alpha, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, alpha, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), I_ ( dimensionedSymmTensor ( "I", dimensionSet(0, 0, 0, 0, 0, 0, 0), symmTensor ( 1, 0, 0, 1, 0, 1 ) ) ), etaS1_(dict.subDict("phase1").lookup("etaS")), etaS2_(dict.subDict("phase2").lookup("etaS")), etaP1_(dict.subDict("phase1").lookup("etaP")), etaP2_(dict.subDict("phase2").lookup("etaP")), alpha1_(dict.subDict("phase1").lookup("alpha")), alpha2_(dict.subDict("phase2").lookup("alpha")), lambdaOb1_(dict.subDict("phase1").lookup("lambdaOb")), lambdaOb2_(dict.subDict("phase2").lookup("lambdaOb")), lambdaOs1_(dict.subDict("phase1").lookup("lambdaOs")), lambdaOs2_(dict.subDict("phase2").lookup("lambdaOs")), q1_(dict.subDict("phase1").lookup("q")), q2_(dict.subDict("phase2").lookup("q")), pt_ ( dimensionedScalar ( "zero", lambdaOb1_.dimensions(), scalar( SMALL ) ) ) {}
autoPtr<LESModel> LESModel::New ( const volScalarField& rho, const volVectorField& U, const surfaceScalarField& phi, const basicThermo& thermoPhysicalModel, const word& turbulenceModelName ) { // get model name, but do not register the dictionary // otherwise it is registered in the database twice const word modelType ( IOdictionary ( IOobject ( "LESProperties", U.time().constant(), U.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false ) ).lookup("LESModel") ); Info<< "Selecting LES turbulence model " << modelType << endl; dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(modelType); if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalErrorIn ( "LESModel::New" "(" "const volScalarField&, " "const volVectorField&, " "const surfaceScalarField&, " "const basicThermo&, " "const word&" ")" ) << "Unknown LESModel type " << modelType << nl << nl << "Valid LESModel types:" << endl << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError); } return autoPtr<LESModel> ( cstrIter()(rho, U, phi, thermoPhysicalModel, turbulenceModelName) ); }
autoPtr<turbulenceModel> turbulenceModel::New ( const volVectorField& U, const surfaceScalarField& phi, transportModel& transport, const word& turbulenceModelName ) { // get model name, but do not register the dictionary // otherwise it is registered in the database twice const word modelType ( IOdictionary ( IOobject ( "turbulenceProperties", U.time().constant(), U.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false ) ).lookup("simulationType") ); Info<< "Selecting turbulence model type " << modelType << endl; turbulenceModelConstructorTable::iterator cstrIter = turbulenceModelConstructorTablePtr_->find(modelType); if (cstrIter == turbulenceModelConstructorTablePtr_->end()) { FatalErrorIn ( "turbulenceModel::New(const volVectorField&, " "const surfaceScalarField&, transportModel&, const word&)" ) << "Unknown turbulenceModel type " << modelType << nl << nl << "Valid turbulenceModel types:" << endl << turbulenceModelConstructorTablePtr_->sortedToc() << exit(FatalError); } return autoPtr<turbulenceModel> ( cstrIter()(U, phi, transport, turbulenceModelName) ); }
Foam::autoPtr<Foam::phaseChangeTwoPhaseMixture> Foam::phaseChangeTwoPhaseMixture::New ( const volVectorField& U, const surfaceScalarField& phi, const word& alpha1Name ) { IOdictionary transportPropertiesDict ( IOobject ( "transportProperties", U.time().constant(), U.db(), IOobject::MUST_READ, IOobject::NO_WRITE, false ) ); word phaseChangeTwoPhaseMixtureTypeName ( transportPropertiesDict.lookup("phaseChangeTwoPhaseMixture") ); Info<< "Selecting phaseChange model " << phaseChangeTwoPhaseMixtureTypeName << endl; componentsConstructorTable::iterator cstrIter = componentsConstructorTablePtr_ ->find(phaseChangeTwoPhaseMixtureTypeName); if (cstrIter == componentsConstructorTablePtr_->end()) { FatalErrorIn ( "phaseChangeTwoPhaseMixture::New" ) << "Unknown phaseChangeTwoPhaseMixture type " << phaseChangeTwoPhaseMixtureTypeName << endl << endl << "Valid phaseChangeTwoPhaseMixtures are : " << endl << componentsConstructorTablePtr_->toc() << exit(FatalError); } return autoPtr<phaseChangeTwoPhaseMixture>(cstrIter()(U, phi, alpha1Name)); }
transportModel::transportModel ( const volVectorField& U, const surfaceScalarField& phi ) : IOdictionary ( IOobject ( "transportProperties", U.time().constant(), U.db(), IOobject::MUST_READ, IOobject::NO_WRITE ) ) {}
Foam::S_MDCPP::S_MDCPP ( const word& name, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), I_ ( dimensionedSymmTensor ( "I", dimensionSet(0, 0, 0, 0, 0, 0, 0), symmTensor ( 1, 0, 0, 1, 0, 1 ) ) ), rho_(dict.lookup("rho")), etaS_(dict.lookup("etaS")), etaP_(dict.lookup("etaP")), zeta_(dict.lookup("zeta")), lambdaOb_(dict.lookup("lambdaOb")), lambdaOs_(dict.lookup("lambdaOs")), q_(dict.lookup("q")) {}
Foam::autoPtr<Foam::SRF::SRFModel> Foam::SRF::SRFModel::New ( const volVectorField& Urel ) { // get model name, but do not register the dictionary // otherwise it is registered in the database twice const word modelType ( IOdictionary ( IOobject ( "SRFProperties", Urel.time().constant(), Urel.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false ) ).lookup("SRFModel") ); Info<< "Selecting SRFModel " << modelType << endl; dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(modelType); if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalErrorIn ( "SRFModel::New(const fvMesh&)" ) << "Unknown SRFModel type " << modelType << nl << nl << "Valid SRFModel types are :" << nl << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError); } return autoPtr<SRFModel>(cstrIter()(Urel)); }
viscoelasticModel::viscoelasticModel ( const volScalarField& alpha, const volVectorField& U, const surfaceScalarField& phi ) : IOdictionary ( IOobject ( "viscoelasticProperties", U.time().constant(), U.db(), IOobject::MUST_READ, IOobject::NO_WRITE ) ), lawPtr_(viscoelasticLaw::New(word::null, alpha, U, phi, subDict("rheology"))) {}
Foam::autoPtr<Foam::laminarModel<BasicTurbulenceModel>> Foam::laminarModel<BasicTurbulenceModel>::New ( const alphaField& alpha, const rhoField& rho, const volVectorField& U, const surfaceScalarField& alphaRhoPhi, const surfaceScalarField& phi, const transportModel& transport, const word& propertiesName ) { IOdictionary modelDict ( IOobject ( IOobject::groupName(propertiesName, U.group()), U.time().constant(), U.db(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false ) ); if (modelDict.found("laminar")) { // get model name, but do not register the dictionary // otherwise it is registered in the database twice const word modelType ( modelDict.subDict("laminar").lookup("laminarModel") ); Info<< "Selecting laminar stress model " << modelType << endl; typename dictionaryConstructorTable::iterator cstrIter = dictionaryConstructorTablePtr_->find(modelType); if (cstrIter == dictionaryConstructorTablePtr_->end()) { FatalErrorInFunction << "Unknown laminarModel type " << modelType << nl << nl << "Valid laminarModel types:" << endl << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError); } return autoPtr<laminarModel> ( cstrIter() ( alpha, rho, U, alphaRhoPhi, phi, transport, propertiesName) ); } else { Info<< "Selecting laminar stress model " << laminarModels::Stokes<BasicTurbulenceModel>::typeName << endl; return autoPtr<laminarModel> ( new laminarModels::Stokes<BasicTurbulenceModel> ( alpha, rho, U, alphaRhoPhi, phi, transport, propertiesName ) ); } }
Foam::Leonov::Leonov ( const word& name, const volScalarField& alpha, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, alpha, U, phi), sigma_ ( IOobject ( "sigma" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), U.mesh(), dimensionedSymmTensor ( "zero", dimensionSet(1, -1, -2, 0, 0, 0, 0), symmTensor::zero ) ), I_ ( dimensionedSymmTensor ( "I", dimensionSet(0, 0, 0, 0, 0, 0, 0), symmTensor ( 1, 0, 0, 1, 0, 1 ) ) ), rho1_(dict.subDict("phase1").lookup("rho")), rho2_(dict.subDict("phase2").lookup("rho")), etaS1_(dict.subDict("phase1").lookup("etaS")), etaS2_(dict.subDict("phase2").lookup("etaS")), etaP1_(dict.subDict("phase1").lookup("etaP")), etaP2_(dict.subDict("phase2").lookup("etaP")), lambda1_(dict.subDict("phase1").lookup("lambda")), lambda2_(dict.subDict("phase2").lookup("lambda")) {}
// Construct from components Foam::spray::spray ( const volVectorField& U, const volScalarField& rho, const volScalarField& p, const volScalarField& T, const basicMultiComponentMixture& composition, const PtrList<gasThermoPhysics>& gasProperties, const dictionary&, const dimensionedVector& g, bool readFields ) : Cloud<parcel>(U.mesh(), false), // suppress className checking on positions runTime_(U.time()), time0_(runTime_.value()), mesh_(U.mesh()), rndGen_(label(0)), g_(g.value()), U_(U), rho_(rho), p_(p), T_(T), sprayProperties_ ( IOobject ( "sprayProperties", U.time().constant(), U.db(), IOobject::MUST_READ, IOobject::NO_WRITE ) ), ambientPressure_(p_.average().value()), ambientTemperature_(T_.average().value()), injectors_ ( IOobject ( "injectorProperties", U.time().constant(), U.db(), IOobject::MUST_READ, IOobject::NO_WRITE ), injector::iNew(U.time()) ), atomization_ ( atomizationModel::New ( sprayProperties_, *this ) ), drag_ ( dragModel::New ( sprayProperties_ ) ), evaporation_ ( evaporationModel::New ( sprayProperties_ ) ), heatTransfer_ ( heatTransferModel::New ( sprayProperties_ ) ), wall_ ( wallModel::New ( sprayProperties_, U, *this ) ), breakupModel_ ( breakupModel::New ( sprayProperties_, *this ) ), collisionModel_ ( collisionModel::New ( sprayProperties_, *this, rndGen_ ) ), dispersionModel_ ( dispersionModel::New ( sprayProperties_, *this ) ), fuels_ ( liquidMixture::New ( mesh_.lookupObject<dictionary>("thermophysicalProperties") ) ), injectorModel_ ( injectorModel::New ( sprayProperties_, *this ) ), sprayIteration_(sprayProperties_.subDict("sprayIteration")), sprayIterate_(readLabel(sprayIteration_.lookup("sprayIterate"))), sprayRelaxFactor_(readScalar(sprayIteration_.lookup("sprayRelaxFactor"))), minimumParcelMass_ ( readScalar(sprayIteration_.lookup("minimumParcelMass")) ), subCycles_(readLabel(sprayProperties_.lookup("subCycles"))), gasProperties_(gasProperties), composition_(composition), liquidToGasIndex_(fuels_->components().size(), -1), gasToLiquidIndex_(composition.Y().size(), -1), isLiquidFuel_(composition.Y().size(), false), twoD_(0), axisOfSymmetry_(vector::zero), axisOfWedge_(vector(0,0,0)), axisOfWedgeNormal_(vector(0,0,0)), angleOfWedge_(0.0), interpolationSchemes_(sprayProperties_.subDict("interpolationSchemes")), UInterpolator_(NULL), rhoInterpolator_(NULL), pInterpolator_(NULL), TInterpolator_(NULL), sms_(mesh_.nCells(), vector::zero), shs_(mesh_.nCells(), 0.0), srhos_(fuels_->components().size()), totalInjectedLiquidMass_(0.0), injectedLiquidKE_(0.0) { // create the evaporation source fields forAll(srhos_, i) { srhos_.set(i, new scalarField(mesh_.nCells(), 0.0)); }
Foam::XPP_DE::XPP_DE ( const word& name, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, U, phi), S_ ( IOobject ( "S" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), Lambda_ ( IOobject ( "Lambda" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), U.mesh(), dimensionedSymmTensor ( "zero", dimensionSet(1, -1, -2, 0, 0, 0, 0), symmTensor::zero ) ), I_ ( dimensionedSymmTensor ( "I", dimensionSet(0, 0, 0, 0, 0, 0, 0), symmTensor ( 1, 0, 0, 1, 0, 1 ) ) ), rho_(dict.lookup("rho")), etaS_(dict.lookup("etaS")), etaP_(dict.lookup("etaP")), alpha_(dict.lookup("alpha")), lambdaOb_(dict.lookup("lambdaOb")), lambdaOs_(dict.lookup("lambdaOs")), q_(dict.lookup("q")) {}
// from components Feta_PTT::Feta_PTT ( const word& name, const volScalarField& alpha, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, alpha, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), etaS1_(dict.subDict("phase1").lookup("etaS")), etaS2_(dict.subDict("phase2").lookup("etaS")), etaP1_(dict.subDict("phase1").lookup("etaP")), etaP2_(dict.subDict("phase2").lookup("etaP")), lambda1_(dict.subDict("phase1").lookup("lambda")), lambda2_(dict.subDict("phase2").lookup("lambda")), epsilon1_(dict.subDict("phase1").lookup("epsilon")), epsilon2_(dict.subDict("phase2").lookup("epsilon")), zeta1_(dict.subDict("phase1").lookup("zeta")), zeta2_(dict.subDict("phase2").lookup("zeta")), A1_(dict.subDict("phase1").lookup("A")), A2_(dict.subDict("phase2").lookup("A")), a1_(dict.subDict("phase1").lookup("a")), a2_(dict.subDict("phase2").lookup("a")), b1_(dict.subDict("phase1").lookup("b")), b2_(dict.subDict("phase2").lookup("b")), alpha1f_ ( IOobject ( "alpha1f" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::NO_WRITE ), min(max(alpha, scalar(0)), scalar(1)) ), etaPEff_ ( IOobject ( "etaPEff" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), (etaP1_/( Foam::pow(scalar(1) + A1_*Foam::pow(0.5*( Foam::sqr(tr(tau_)) - tr(tau_ & tau_) ) * Foam::sqr(lambda1_) / Foam::sqr(etaP1_), a1_), b1_) ) )*alpha1f_ + (etaP2_/( Foam::pow(scalar(1) + A2_*Foam::pow(0.5*( Foam::sqr(tr(tau_)) - tr(tau_ & tau_) ) * Foam::sqr(lambda2_) / Foam::sqr(etaP2_), a2_), b2_) ) )*(scalar(1) - alpha1f_) ), lambdaEff_ ( IOobject ( "lambdaEff" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), (lambda1_ / (scalar(1) + epsilon1_*lambda1_*tr(tau_) / etaP1_) )*alpha1f_ + (lambda2_ / (scalar(1) + epsilon2_*lambda2_*tr(tau_) / etaP2_) )*(scalar(1) - alpha1f_) ) {}