void Foam::MULES::explicitSolve ( const RhoType& rho, volScalarField& psi, const surfaceScalarField& phi, surfaceScalarField& phiPsi, const SpType& Sp, const SuType& Su, const scalar psiMax, const scalar psiMin ) { psi.correctBoundaryConditions(); limit(rho, psi, phi, phiPsi, Sp, Su, psiMax, psiMin, 3, false); explicitSolve(rho, psi, phiPsi, Sp, Su); }
Foam::tmp<Foam::volScalarField> Foam::populationBalanceSubModels::growthModels::constantGrowth::Kg ( const volScalarField& abscissa ) const { dimensionedScalar oneAbs ( "oneAbs", dimVolume/sqr(abscissa.dimensions()), 1.0 ); return Cg_*pos(-abscissa + maxAbscissa_) *pos(abscissa - minAbscissa_)*oneAbs; }
tmp<GeometricField<Type, fvPatchField, volMesh> > d2dt2 ( const volScalarField& rho, const GeometricField<Type, fvPatchField, volMesh>& vf ) { return fv::d2dt2Scheme<Type>::New ( vf.mesh(), vf.mesh().schemesDict().ddtScheme ( "d2dt2(" + rho.name() + ',' + vf.name() + ')' ) )().fvcD2dt2(rho, vf); }
void Foam::functionObjects::yPlus::calcYPlus ( const turbulenceModel& turbModel, volScalarField& yPlus ) { volScalarField::Boundary d = nearWallDist(mesh_).y(); const volScalarField::Boundary nutBf = turbModel.nut()().boundaryField(); const volScalarField::Boundary nuEffBf = turbModel.nuEff()().boundaryField(); const volScalarField::Boundary nuBf = turbModel.nu()().boundaryField(); const fvPatchList& patches = mesh_.boundary(); volScalarField::Boundary& yPlusBf = yPlus.boundaryFieldRef(); forAll(patches, patchi) { const fvPatch& patch = patches[patchi]; if (isA<nutWallFunctionFvPatchScalarField>(nutBf[patchi])) { const nutWallFunctionFvPatchScalarField& nutPf = dynamic_cast<const nutWallFunctionFvPatchScalarField&> ( nutBf[patchi] ); yPlusBf[patchi] = nutPf.yPlus(); } else if (isA<wallFvPatch>(patch)) { yPlusBf[patchi] = d[patchi] *sqrt ( nuEffBf[patchi] *mag(turbModel.U().boundaryField()[patchi].snGrad()) )/nuBf[patchi]; } } }
void dense::setScalarAverage ( volScalarField& field, double**& value, double**& weight, volScalarField& weightField, double**const& mask ) const { label cellI; scalar valueScal; scalar weightP; for(int index=0; index< particleCloud_.numberOfParticles(); index++) { if(mask[index][0]) { for(int subCell=0;subCell<particleCloud_.voidFractionM().cellsPerParticle()[index][0];subCell++) { //Info << "subCell=" << subCell << endl; cellI = particleCloud_.cellIDs()[index][subCell]; if (cellI >= 0) { valueScal = value[index][0]; weightP = weight[index][0]; // first entry in this cell if(weightField[cellI] == 0) { field[cellI] = valueScal; weightField[cellI] = weightP; } else { field[cellI] = (field[cellI]*weightField[cellI]+valueScal*weightP)/(weightField[cellI]+weightP); weightField[cellI] += weightP; } } } } } // correct cell values to patches field.correctBoundaryConditions(); }
void Foam::compressibleTwoPhaseMixtureThermo::heBoundaryCorrection(volScalarField& h) { volScalarField::GeometricBoundaryField& hbf = h.boundaryField(); forAll(hbf, patchi) { if (isA<gradientEnergyFvPatchScalarField>(hbf[patchi])) { refCast<gradientEnergyFvPatchScalarField>(hbf[patchi]).gradient() = hbf[patchi].fvPatchField::snGrad(); } else if (isA<mixedEnergyFvPatchScalarField>(hbf[patchi])) { refCast<mixedEnergyFvPatchScalarField>(hbf[patchi]).refGrad() = hbf[patchi].fvPatchField::snGrad(); } } }
tmp<fvMatrix<Type> > steadyStateDdtScheme<Type>::fvmDdt ( const volScalarField& rho, const GeometricField<Type, fvPatchField, volMesh>& vf ) { tmp<fvMatrix<Type> > tfvm ( new fvMatrix<Type> ( vf, rho.dimensions()*vf.dimensions()*dimVol/dimTime ) ); return tfvm; }
void Foam::fv::limitTemperature::correct(volScalarField& he) { const basicThermo& thermo = mesh_.lookupObject<basicThermo>(basicThermo::dictName); scalarField Tmin(cells_.size(), Tmin_); scalarField Tmax(cells_.size(), Tmax_); scalarField heMin(thermo.he(thermo.p(), Tmin, cells_)); scalarField heMax(thermo.he(thermo.p(), Tmax, cells_)); scalarField& hec = he.internalField(); forAll(cells_, i) { label cellI = cells_[i]; hec[cellI]= max(min(hec[cellI], heMax[i]), heMin[i]); }
void Foam::basicThermo::hBoundaryCorrection(volScalarField& h) { volScalarField::GeometricBoundaryField& hbf = h.boundaryField(); forAll(hbf, patchi) { if (isA<gradientEnthalpyFvPatchScalarField>(hbf[patchi])) { refCast<gradientEnthalpyFvPatchScalarField>(hbf[patchi]).gradient() = hbf[patchi].fvPatchField::snGrad(); } else if (isA<mixedEnthalpyFvPatchScalarField>(hbf[patchi])) { refCast<mixedEnthalpyFvPatchScalarField>(hbf[patchi]).refGrad() = hbf[patchi].fvPatchField::snGrad(); } } }
void Foam::basicThermo::eBoundaryCorrection(volScalarField& e) { volScalarField::GeometricBoundaryField& ebf = e.boundaryField(); forAll(ebf, patchi) { if (isA<gradientInternalEnergyFvPatchScalarField>(ebf[patchi])) { refCast<gradientInternalEnergyFvPatchScalarField>(ebf[patchi]) .gradient() = ebf[patchi].fvPatchField::snGrad(); } else if (isA<mixedInternalEnergyFvPatchScalarField>(ebf[patchi])) { refCast<mixedInternalEnergyFvPatchScalarField>(ebf[patchi]) .refGrad() = ebf[patchi].fvPatchField::snGrad(); } } }
Foam::scalar Foam::power::rho(const volScalarField& p) const { if (p.dimensions() == dimPressure) { return 1.0; } else { if (rhoName_ != "rhoInf") { FatalErrorIn("power::rho(const volScalarField& p)") << "Dynamic pressure is expected but kinematic is provided." << exit(FatalError); } return rhoRef_; } }
Foam::phaseModel::phaseModel ( const word& phaseName, const volScalarField& p, const volScalarField& T ) : volScalarField ( IOobject ( IOobject::groupName("alpha", phaseName), p.mesh().time().timeName(), p.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), p.mesh() ), name_(phaseName), p_(p), T_(T), thermo_(NULL), dgdt_ ( IOobject ( IOobject::groupName("dgdt", phaseName), p.mesh().time().timeName(), p.mesh(), IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE ), p.mesh(), dimensionedScalar("0", dimless/dimTime, 0) ) { { volScalarField Tp(IOobject::groupName("T", phaseName), T); Tp.write(); } thermo_ = rhoThermo::New(p.mesh(), phaseName); thermo_->validate(phaseName, "e"); correct(); }
wordList mixtureKEpsilon<BasicTurbulenceModel>::epsilonBoundaryTypes ( const volScalarField& epsilon ) const { const volScalarField::GeometricBoundaryField& ebf = epsilon.boundaryField(); wordList ebt = ebf.types(); forAll(ebf, patchi) { if (isA<fixedValueFvPatchScalarField>(ebf[patchi])) { ebt[patchi] = fixedValueFvPatchScalarField::typeName; } } return ebt; }
void Foam::heThermo<BasicThermo, MixtureType>:: heBoundaryCorrection(volScalarField& h) { volScalarField::Boundary& hBf = h.boundaryFieldRef(); forAll(hBf, patchi) { if (isA<gradientEnergyFvPatchScalarField>(hBf[patchi])) { refCast<gradientEnergyFvPatchScalarField>(hBf[patchi]).gradient() = hBf[patchi].fvPatchField::snGrad(); } else if (isA<mixedEnergyFvPatchScalarField>(hBf[patchi])) { refCast<mixedEnergyFvPatchScalarField>(hBf[patchi]).refGrad() = hBf[patchi].fvPatchField::snGrad(); } } }
tmp<volScalarField> SpalartAllmarasIDDES<BasicTurbulenceModel>::rd ( const volScalarField& nur, const volScalarField& magGradU ) const { return min ( nur /( max ( magGradU, dimensionedScalar("SMALL", magGradU.dimensions(), SMALL) )*sqr(this->kappa_*this->y_) ), scalar(10) ); }
void writeCellGraph ( const volScalarField& vsf, const word& graphFormat ) { fileName path(vsf.time().path()/"graphs"/vsf.time().timeName()); mkDir(path); graph ( vsf.name(), "x", vsf.name(), vsf.mesh().C().primitiveField().component(vector::X), vsf.primitiveField() ).write(path/vsf.name(), graphFormat); }
tmp<GeometricField<typename flux<Type>::type, fvsPatchField, surfaceMesh> > ddtPhiCorr ( const volScalarField& rA, const volScalarField& rho, const GeometricField<Type, fvPatchField, volMesh>& U, const GeometricField < typename flux<Type>::type, fvsPatchField, surfaceMesh >& phi ) { return fv::ddtScheme<Type>::New ( U.mesh(), U.mesh().ddtScheme("ddt(" + rho.name() + ',' + U.name() + ')') )().fvcDdtPhiCorr(rA, rho, U, phi); }
isoBubble::isoBubble ( const IOobject& io, const volScalarField& isoField, bool isTime , scalar isoValue, label timeIndexPad, word outputFormat, bool regularize ) : regIOobject(io, isTime), isoPointField_(isoField.mesh().nPoints(),0), bubblePtr_(), timeIndexPad_(timeIndexPad), outputFormat_(outputFormat) { // Reconstruct immediately using the tracked field. reconstruct(isoField, isoValue, regularize); }
void dilute::setScalarAverage ( volScalarField& field, double**& value, double**& weight, volScalarField& weightField, double**const& mask, double**const& weight2, //allows the specification of a 2nd weight field bool weightWithWeight2 //switch to activate 2nd weight field ) const { label cellI; scalar valueScal; scalar weightP; if(weightWithWeight2) FatalError << "dilute::setScalarAverage: attempt to weight with weight2, which is not implemented" << abort(FatalError); for(int index=0; index< particleCloud_.numberOfParticles(); index++) { for(int subCell=0;subCell<particleCloud_.cellsPerParticle()[index][0];subCell++) { //Info << "subCell=" << subCell << endl; cellI = particleCloud_.cellIDs()[index][subCell]; if (cellI >= 0) { valueScal = value[index][0]; weightP = weight[index][0]; weightField[cellI] += weightP; field[cellI] = valueScal/weightP; } } } // correct cell values to patches field.correctBoundaryConditions(); }
void Foam::MULES::explicitSolve ( const RhoType& rho, volScalarField& psi, const surfaceScalarField& phiPsi, const SpType& Sp, const SuType& Su ) { const fvMesh& mesh = psi.mesh(); if (fv::localEulerDdt::enabled(mesh)) { const volScalarField& rDeltaT = fv::localEulerDdt::localRDeltaT(mesh); explicitSolve(rDeltaT, rho, psi, phiPsi, Sp, Su); } else { const scalar rDeltaT = 1.0/mesh.time().deltaTValue(); explicitSolve(rDeltaT, rho, psi, phiPsi, Sp, Su); } }
Foam::scalar Foam::compressibleCourantNo ( const fvMesh& mesh, const Time& runTime, const volScalarField& rho, const surfaceScalarField& phi ) { scalarField sumPhi ( fvc::surfaceSum(mag(phi))().primitiveField() / rho.primitiveField() ); scalar CoNum = 0.5*gMax(sumPhi/mesh.V().field())*runTime.deltaTValue(); scalar meanCoNum = 0.5*(gSum(sumPhi)/gSum(mesh.V().field()))*runTime.deltaTValue(); Info<< "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum << " max: " << CoNum << endl; return CoNum; }
void Foam::setRefCell ( const volScalarField& field, const volScalarField& fieldRef, const dictionary& dict, label& refCelli, scalar& refValue, const bool forceReference ) { if (fieldRef.needReference() || forceReference) { word refCellName = field.name() + "RefCell"; word refPointName = field.name() + "RefPoint"; word refValueName = field.name() + "RefValue"; if (dict.found(refCellName)) { if (Pstream::master()) { refCelli = readLabel(dict.lookup(refCellName)); if (refCelli < 0 || refCelli >= field.mesh().nCells()) { FatalIOErrorIn ( "void Foam::setRefCell\n" "(\n" " const volScalarField&,\n" " const volScalarField&,\n" " const dictionary&,\n" " label& scalar&,\n" " bool\n" ")", dict ) << "Illegal master cellID " << refCelli << ". Should be 0.." << field.mesh().nCells() << exit(FatalIOError); } } else { refCelli = -1; } } else if (dict.found(refPointName)) { point refPointi(dict.lookup(refPointName)); refCelli = field.mesh().findCell(refPointi); label hasRef = (refCelli >= 0 ? 1 : 0); label sumHasRef = returnReduce<label>(hasRef, sumOp<label>()); if (sumHasRef != 1) { FatalIOErrorIn ( "void Foam::setRefCell\n" "(\n" " const volScalarField&,\n" " const volScalarField&,\n" " const dictionary&,\n" " label& scalar&,\n" " bool\n" ")", dict ) << "Unable to set reference cell for field " << field.name() << nl << " Reference point " << refPointName << " " << refPointi << " found on " << sumHasRef << " domains (should be one)" << nl << exit(FatalIOError); } } else { FatalIOErrorIn ( "void Foam::setRefCell\n" "(\n" " const volScalarField&,\n" " const volScalarField&,\n" " const dictionary&,\n" " label& scalar&,\n" " bool\n" ")", dict ) << "Unable to set reference cell for field " << field.name() << nl << " Please supply either " << refCellName << " or " << refPointName << nl << exit(FatalIOError); } refValue = readScalar(dict.lookup(refValueName)); } }
void thixotropicViscosity::correct ( const volScalarField& p, const volScalarField& T ) { const kinematicSingleLayer& film = filmType<kinematicSingleLayer>(); const volVectorField& U = film.U(); const volVectorField& Uw = film.Uw(); const volScalarField& delta = film.delta(); const volScalarField& deltaRho = film.deltaRho(); const surfaceScalarField& phi = film.phi(); const volScalarField& alpha = film.alpha(); const Time& runTime = this->film().regionMesh().time(); // Shear rate const volScalarField gDot ( "gDot", alpha*mag(U - Uw)/(delta + film.deltaSmall()) ); if (debug && runTime.writeTime()) { gDot.write(); } const dimensionedScalar deltaRho0 ( "deltaRho0", deltaRho.dimensions(), rootVSmall ); const surfaceScalarField phiU(phi/fvc::interpolate(deltaRho + deltaRho0)); const dimensionedScalar c0("c0", dimless/dimTime, rootVSmall); const volScalarField coeff("coeff", -c_*pow(gDot, d_) + c0); fvScalarMatrix lambdaEqn ( fvm::ddt(lambda_) + fvm::div(phiU, lambda_) - fvm::Sp(fvc::div(phiU), lambda_) == a_*pow((1 - lambda_), b_) + fvm::SuSp(coeff, lambda_) // Include the effect of the impinging droplets added with lambda = 0 - fvm::Sp ( max ( -film.rhoSp(), dimensionedScalar(film.rhoSp().dimensions(), 0) )/(deltaRho + deltaRho0), lambda_ ) ); lambdaEqn.relax(); lambdaEqn.solve(); lambda_.min(1); lambda_.max(0); mu_ = muInf_/(sqr(1 - K_*lambda_) + rootVSmall); mu_.correctBoundaryConditions(); }
Foam::capillarityModels::pcVanGenuchten::pcVanGenuchten ( const word& name, const dictionary& transportProperties, const volScalarField& Sb ) : capillarityModel(name, transportProperties,Sb), pcVanGenuchtenCoeffs_(transportProperties.subDict(typeName + "Coeffs")), Smin_ ( IOobject ( Sb_.name()+"min", Sb_.time().timeName(), Sb_.db(), IOobject::READ_IF_PRESENT, IOobject::NO_WRITE ), Sb.mesh(), transportProperties.lookupOrDefault(Sb_.name()+"min",dimensionedScalar(Sb_.name()+"min",dimless,0)) ), Smax_ ( IOobject ( Sb_.name()+"max", Sb_.time().timeName(), Sb_.db(), IOobject::READ_IF_PRESENT, IOobject::NO_WRITE ), Sb.mesh(), transportProperties.lookupOrDefault(Sb_.name()+"max",dimensionedScalar(Sb_.name()+"max",dimless,0)) ), m_ ( IOobject ( "m", Sb_.time().timeName(), Sb_.db(), IOobject::READ_IF_PRESENT, IOobject::NO_WRITE ), Sb.mesh(), dimensionedScalar("m",dimless,pcVanGenuchtenCoeffs_.lookupOrDefault<scalar>("m",0)) ), n_(1/(1-m_)), alpha_ // necessary for Richards solver ( IOobject ( "alpha", Sb_.time().timeName(), Sb_.db(), IOobject::READ_IF_PRESENT, IOobject::NO_WRITE ), Sb.mesh(), dimensionedScalar("alpha",dimless,pcVanGenuchtenCoeffs_.lookupOrDefault<scalar>("alpha",0)) ), pc0_ ( IOobject ( "pc0", Sb_.time().timeName(), Sb_.db(), IOobject::READ_IF_PRESENT, IOobject::NO_WRITE ), Sb.mesh(), pcVanGenuchtenCoeffs_.lookupOrDefault("pc0",dimensionedScalar("pc0",dimensionSet(1,-1,-2,0,0),0.)) ), Se_((Sb_- Smin_)/(Smax_-Smin_)) { if (gMin(m_) == 0) FatalErrorIn("Foam::capillarityModels::pcVanGenuchten::pcVanGenuchten") << "m = 0 in pcVanGenuchten" << abort(FatalError); Info << "Van Genuchten parameters for capillary pressure model" << nl << "{" << endl; Info << " m "; if (m_.headerOk()) { Info << "read file" << endl;} else {Info << average(m_).value() << endl;} Info << " pc0 "; if (pc0_.headerOk()) { Info << "read file" << endl;} else {Info << average(pc0_).value() << endl;} Info << " alpha "; if (alpha_.headerOk()) { Info << "read file" << endl;} else {Info << average(alpha_).value() << endl;} Info << " Smin "; if (Smin_.headerOk()) { Info << "read file" << endl;} else {Info << average(Smin_).value() << endl;} Info << " Smax "; if (Smax_.headerOk()) { Info << "read file" << endl;} else {Info << average(Smax_).value() << endl;} Info << "} \n" << endl; }
void Foam::MULES::explicitSolve ( const RhoType& rho, volScalarField& psi, const surfaceScalarField& phi, surfaceScalarField& phiPsi, const SpType& Sp, const SuType& Su, const scalar psiMax, const scalar psiMin ) { Info<< "MULES: Solving for " << psi.name() << endl; const fvMesh& mesh = psi.mesh(); psi.correctBoundaryConditions(); surfaceScalarField phiBD(upwind<scalar>(psi.mesh(), phi).flux(psi)); surfaceScalarField& phiCorr = phiPsi; phiCorr -= phiBD; scalarField allLambda(mesh.nFaces(), 1.0); slicedSurfaceScalarField lambda ( IOobject ( "lambda", mesh.time().timeName(), mesh, IOobject::NO_READ, IOobject::NO_WRITE, false ), mesh, dimless, allLambda, false // Use slices for the couples ); limiter ( allLambda, rho, psi, phiBD, phiCorr, Sp, Su, psiMax, psiMin, 3 ); phiPsi = phiBD + lambda*phiCorr; scalarField& psiIf = psi; const scalarField& psi0 = psi.oldTime(); const scalar deltaT = mesh.time().deltaTValue(); psiIf = 0.0; fvc::surfaceIntegrate(psiIf, phiPsi); if (mesh.moving()) { psiIf = ( mesh.Vsc0()().field()*rho.oldTime().field() *psi0/(deltaT*mesh.Vsc()().field()) + Su.field() - psiIf )/(rho.field()/deltaT - Sp.field()); } else { psiIf = ( rho.oldTime().field()*psi0/deltaT + Su.field() - psiIf )/(rho.field()/deltaT - Sp.field()); } psi.correctBoundaryConditions(); }
int main(int argc, char *argv[]) { timeSelector::addOptions(); #include "setRootCase.H" #include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); #include "createMesh.H" #include "createFields.H" forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; // Cache the turbulence fields Info<< "\nRetrieving field k from turbulence model" << endl; const volScalarField k = RASModel->k(); Info<< "\nRetrieving field epsilon from turbulence model" << endl; const volScalarField epsilon = RASModel->epsilon(); Info<< "\nRetrieving field R from turbulence model" << endl; const volSymmTensorField R = RASModel->R(); // Check availability of tubulence fields if (!IOobject("k", runTime.timeName(), mesh).headerOk()) { Info<< "\nWriting turbulence field k" << endl; k.write(); } else { Info<< "\nTurbulence k field already exists" << endl; } if (!IOobject("epsilon", runTime.timeName(), mesh).headerOk()) { Info<< "\nWriting turbulence field epsilon" << endl; epsilon.write(); } else { Info<< "\nTurbulence epsilon field already exists" << endl; } if (!IOobject("R", runTime.timeName(), mesh).headerOk()) { Info<< "\nWriting turbulence field R" << endl; R.write(); } else { Info<< "\nTurbulence R field already exists" << endl; } if (!IOobject("omega", runTime.timeName(), mesh).headerOk()) { const scalar Cmu = 0.09; Info<< "creating omega" << endl; volScalarField omega ( IOobject ( "omega", runTime.timeName(), mesh ), epsilon/(Cmu*k), epsilon.boundaryField().types() ); Info<< "\nWriting turbulence field omega" << endl; omega.write(); } else { Info<< "\nTurbulence omega field already exists" << endl; } }
void Foam::MULES::limiter ( scalarField& allLambda, const RdeltaTType& rDeltaT, const RhoType& rho, const volScalarField& psi, const surfaceScalarField& phiBD, const surfaceScalarField& phiCorr, const SpType& Sp, const SuType& Su, const scalar psiMax, const scalar psiMin ) { const scalarField& psiIf = psi; const volScalarField::GeometricBoundaryField& psiBf = psi.boundaryField(); const fvMesh& mesh = psi.mesh(); const dictionary& MULEScontrols = mesh.solverDict(psi.name()); label nLimiterIter ( MULEScontrols.lookupOrDefault<label>("nLimiterIter", 3) ); scalar smoothLimiter ( MULEScontrols.lookupOrDefault<scalar>("smoothLimiter", 0) ); const scalarField& psi0 = psi.oldTime(); const labelUList& owner = mesh.owner(); const labelUList& neighb = mesh.neighbour(); tmp<volScalarField::DimensionedInternalField> tVsc = mesh.Vsc(); const scalarField& V = tVsc(); const scalarField& phiBDIf = phiBD; const surfaceScalarField::GeometricBoundaryField& phiBDBf = phiBD.boundaryField(); const scalarField& phiCorrIf = phiCorr; const surfaceScalarField::GeometricBoundaryField& phiCorrBf = phiCorr.boundaryField(); slicedSurfaceScalarField lambda ( IOobject ( "lambda", mesh.time().timeName(), mesh, IOobject::NO_READ, IOobject::NO_WRITE, false ), mesh, dimless, allLambda, false // Use slices for the couples ); scalarField& lambdaIf = lambda; surfaceScalarField::GeometricBoundaryField& lambdaBf = lambda.boundaryField(); scalarField psiMaxn(psiIf.size(), psiMin); scalarField psiMinn(psiIf.size(), psiMax); scalarField sumPhiBD(psiIf.size(), 0.0); scalarField sumPhip(psiIf.size(), VSMALL); scalarField mSumPhim(psiIf.size(), VSMALL); forAll(phiCorrIf, facei) { label own = owner[facei]; label nei = neighb[facei]; psiMaxn[own] = max(psiMaxn[own], psiIf[nei]); psiMinn[own] = min(psiMinn[own], psiIf[nei]); psiMaxn[nei] = max(psiMaxn[nei], psiIf[own]); psiMinn[nei] = min(psiMinn[nei], psiIf[own]); sumPhiBD[own] += phiBDIf[facei]; sumPhiBD[nei] -= phiBDIf[facei]; scalar phiCorrf = phiCorrIf[facei]; if (phiCorrf > 0.0) { sumPhip[own] += phiCorrf; mSumPhim[nei] += phiCorrf; } else { mSumPhim[own] -= phiCorrf; sumPhip[nei] -= phiCorrf; } }
Foam::KinematicCloud<CloudType>::KinematicCloud ( const word& cloudName, const volScalarField& rho, const volVectorField& U, const volScalarField& mu, const dimensionedVector& g, bool readFields ) : CloudType(rho.mesh(), cloudName, false), kinematicCloud(), cloudCopyPtr_(NULL), mesh_(rho.mesh()), particleProperties_ ( IOobject ( cloudName + "Properties", rho.mesh().time().constant(), rho.mesh(), IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE ) ), solution_(mesh_, particleProperties_.subDict("solution")), constProps_(particleProperties_, solution_.active()), subModelProperties_ ( particleProperties_.subOrEmptyDict("subModels", solution_.active()) ), rndGen_ ( label(0), solution_.steadyState() ? particleProperties_.lookupOrDefault<label>("randomSampleSize", 100000) : -1 ), cellOccupancyPtr_(), rho_(rho), U_(U), mu_(mu), g_(g), pAmbient_(0.0), forces_ ( *this, mesh_, subModelProperties_.subOrEmptyDict ( "particleForces", solution_.active() ), solution_.active() ), functions_ ( *this, particleProperties_.subOrEmptyDict("cloudFunctions"), solution_.active() ), dispersionModel_(NULL), injectionModel_(NULL), patchInteractionModel_(NULL), surfaceFilmModel_(NULL), UIntegrator_(NULL), UTrans_ ( new DimensionedField<vector, volMesh> ( IOobject ( this->name() + "UTrans", this->db().time().timeName(), this->db(), IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE ), mesh_, dimensionedVector("zero", dimMass*dimVelocity, vector::zero) ) ), UCoeff_ ( new DimensionedField<scalar, volMesh> ( IOobject ( this->name() + "UCoeff", this->db().time().timeName(), this->db(), IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE ), mesh_, dimensionedScalar("zero", dimMass, 0.0) ) ) { if (solution_.active()) { setModels(); if (readFields) { parcelType::readFields(*this); } } if (solution_.resetSourcesOnStartup()) { resetSourceTerms(); } }
bool Foam::cfdemCloud::evolve ( volScalarField& alpha, volVectorField& Us, volVectorField& U ) { numberOfParticlesChanged_ = false; arraysReallocated_=false; bool doCouple=false; if(!ignore()) { if (dataExchangeM().couple()) { Info << "\n Coupling..." << endl; doCouple=true; // reset vol Fields clockM().start(16,"resetVolFields"); if(verbose_) { Info << "couplingStep:" << dataExchangeM().couplingStep() << "\n- resetVolFields()" << endl; } averagingM().resetVectorAverage(averagingM().UsPrev(),averagingM().UsNext()); voidFractionM().resetVoidFractions(); averagingM().resetVectorAverage(forceM(0).impParticleForces(),forceM(0).impParticleForces(),true); averagingM().resetVectorAverage(forceM(0).expParticleForces(),forceM(0).expParticleForces(),true); averagingM().resetWeightFields(); for (int i=0;i<momCoupleModels_.size(); i++) momCoupleM(i).resetMomSourceField(); if(verbose_) Info << "resetVolFields done." << endl; clockM().stop("resetVolFields"); if(verbose_) Info << "- getDEMdata()" << endl; clockM().start(17,"getDEMdata"); getDEMdata(); clockM().stop("getDEMdata"); if(verbose_) Info << "- getDEMdata done." << endl; // search cellID of particles clockM().start(18,"findCell"); if(verbose_) Info << "- findCell()" << endl; findCells(); if(verbose_) Info << "findCell done." << endl; clockM().stop("findCell"); // set void fraction field clockM().start(19,"setvoidFraction"); if(verbose_) Info << "- setvoidFraction()" << endl; voidFractionM().setvoidFraction(NULL,voidfractions_,particleWeights_,particleVolumes_); if(verbose_) Info << "setvoidFraction done." << endl; clockM().stop("setvoidFraction"); // set particles velocity field clockM().start(20,"setVectorAverage"); setVectorAverages(); clockM().stop("setVectorAverage"); // set particles forces clockM().start(21,"setForce"); if(verbose_) Info << "- setForce(forces_)" << endl; setForces(); if(verbose_) Info << "setForce done." << endl; clockM().stop("setForce"); // get next force field clockM().start(22,"setParticleForceField"); if(verbose_) Info << "- setParticleForceField()" << endl; averagingM().setVectorSum ( forceM(0).impParticleForces(), impForces_, particleWeights_, NULL //mask ); averagingM().setVectorSum ( forceM(0).expParticleForces(), expForces_, particleWeights_, NULL //mask ); if(verbose_) Info << "- setParticleForceField done." << endl; clockM().stop("setParticleForceField"); // write DEM data if(verbose_) Info << " -giveDEMdata()" << endl; clockM().start(23,"giveDEMdata"); giveDEMdata(); clockM().stop("giveDEMdata"); }//end dataExchangeM().couple() Info << "\n timeStepFraction() = " << dataExchangeM().timeStepFraction() << endl; clockM().start(24,"interpolateEulerFields"); // update smoothing model smoothingM().dSmoothing(); //============================================ // update voidFractionField V1 alpha = voidFractionM().voidFractionInterp(); smoothingM().smoothen(alpha); if(dataExchangeM().couplingStep() < 2) { alpha.oldTime() = alpha; // supress volume src alpha.oldTime().correctBoundaryConditions(); } alpha.correctBoundaryConditions(); // calc ddt(voidfraction) //calcDdtVoidfraction(voidFractionM().voidFractionNext()); calcDdtVoidfraction(alpha); // update particle velocity Field Us = averagingM().UsInterp(); //smoothingM().smoothenReferenceField(Us); Us.correctBoundaryConditions(); /*//============================================ // update voidFractionField volScalarField oldAlpha = alpha.oldTime(); //save old (smooth) alpha field alpha.oldTime().internalField() = voidFractionM().voidFractionInterp(); smoothingM().smoothen(alpha); alpha.correctBoundaryConditions(); alpha.oldTime() = oldAlpha; //set old (smooth) alpha field to allow correct computation of ddt // calc ddt(voidfraction) if (doCouple) calcDdtVoidfraction(alpha); //calcDdtVoidfraction(alpha); // alternative with scale=1! (does not see change in alpha?) // update particle velocity Field Us.oldTime().internalField() = averagingM().UsInterp(); smoothingM().smoothenReferenceField(Us); Us.correctBoundaryConditions(); //============================================*/ clockM().stop("interpolateEulerFields"); if(verbose_){ #include "debugInfo.H" } clockM().start(25,"dumpDEMdata"); // do particle IO IOM().dumpDEMdata(); clockM().stop("dumpDEMdata"); }//end ignore return doCouple; }
void Foam::MULES::implicitSolve ( const RhoType& rho, volScalarField& psi, const surfaceScalarField& phi, surfaceScalarField& phiPsi, const SpType& Sp, const SuType& Su, const scalar psiMax, const scalar psiMin ) { const fvMesh& mesh = psi.mesh(); const dictionary& MULEScontrols = mesh.solverDict(psi.name()); label maxIter ( readLabel(MULEScontrols.lookup("maxIter")) ); label nLimiterIter ( readLabel(MULEScontrols.lookup("nLimiterIter")) ); scalar maxUnboundedness ( readScalar(MULEScontrols.lookup("maxUnboundedness")) ); scalar CoCoeff ( readScalar(MULEScontrols.lookup("CoCoeff")) ); scalarField allCoLambda(mesh.nFaces()); { tmp<surfaceScalarField> Cof = mesh.time().deltaT()*mesh.surfaceInterpolation::deltaCoeffs() *mag(phi)/mesh.magSf(); slicedSurfaceScalarField CoLambda ( IOobject ( "CoLambda", mesh.time().timeName(), mesh, IOobject::NO_READ, IOobject::NO_WRITE, false ), mesh, dimless, allCoLambda, false // Use slices for the couples ); CoLambda == 1.0/max(CoCoeff*Cof, scalar(1)); } scalarField allLambda(allCoLambda); //scalarField allLambda(mesh.nFaces(), 1.0); slicedSurfaceScalarField lambda ( IOobject ( "lambda", mesh.time().timeName(), mesh, IOobject::NO_READ, IOobject::NO_WRITE, false ), mesh, dimless, allLambda, false // Use slices for the couples ); linear<scalar> CDs(mesh); upwind<scalar> UDs(mesh, phi); //fv::uncorrectedSnGrad<scalar> snGrads(mesh); fvScalarMatrix psiConvectionDiffusion ( fvm::ddt(rho, psi) + fv::gaussConvectionScheme<scalar>(mesh, phi, UDs).fvmDiv(phi, psi) //- fv::gaussLaplacianScheme<scalar, scalar>(mesh, CDs, snGrads) //.fvmLaplacian(Dpsif, psi) - fvm::Sp(Sp, psi) - Su ); surfaceScalarField phiBD(psiConvectionDiffusion.flux()); surfaceScalarField& phiCorr = phiPsi; phiCorr -= phiBD; for (label i=0; i<maxIter; i++) { if (i != 0 && i < 4) { allLambda = allCoLambda; } limiter ( allLambda, rho, psi, phiBD, phiCorr, Sp, Su, psiMax, psiMin, nLimiterIter ); solve ( psiConvectionDiffusion + fvc::div(lambda*phiCorr), MULEScontrols ); scalar maxPsiM1 = gMax(psi.internalField()) - 1.0; scalar minPsi = gMin(psi.internalField()); scalar unboundedness = max(max(maxPsiM1, 0.0), -min(minPsi, 0.0)); if (unboundedness < maxUnboundedness) { break; } else { Info<< "MULES: max(" << psi.name() << " - 1) = " << maxPsiM1 << " min(" << psi.name() << ") = " << minPsi << endl; phiBD = psiConvectionDiffusion.flux(); /* word gammaScheme("div(phi,gamma)"); word gammarScheme("div(phirb,gamma)"); const surfaceScalarField& phir = mesh.lookupObject<surfaceScalarField>("phir"); phiCorr = fvc::flux ( phi, psi, gammaScheme ) + fvc::flux ( -fvc::flux(-phir, scalar(1) - psi, gammarScheme), psi, gammarScheme ) - phiBD; */ } } phiPsi = psiConvectionDiffusion.flux() + lambda*phiCorr; }