int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "readThermodynamicProperties.H"
//#include "readTransportProperties.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readPISOControls.H"
#include "compressibleCourantNo.H"
#include "rhoEqn.H"
dimensionedScalar period = dimensionedScalar("period", dimensionSet(0,0,1,0,0,0,0), 5000);
extForceField = extForce * rho / molMass * sin(2*3.1415*runTime.time()/period) ;
fvVectorMatrix UEqn
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
- fvm::laplacian(mu, U)
- extForceField
);
solve(UEqn == -fvc::grad(p));
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
psi = (a0*pow(p,10) + a1*pow(p,9) + a2*pow(p,8) + a3*pow(p,7) + a4*pow(p,6) + a5*pow(p,5)
+ a6*pow(p,4) + a7*pow(p,3) + a8*pow(p,2) + a9*p + a10)/p;
rho = psi*(p);
mu = mu6 * pow(rho,6) + mu5 * pow(rho,5) + mu4 * pow(rho,4) + mu3 * pow(rho,3) + mu2 * pow(rho,2) + mu1 * rho + mu0;
volScalarField rUA = 1.0/UEqn.A();
U = rUA*UEqn.H();
surfaceScalarField phid
(
"phid",
fvc::interpolate(psi)
*(
(fvc::interpolate(U) & mesh.Sf())
+ fvc::ddtCorr(rho, U, phi)
//+ fvc::ddtPhiCorr(rUA, rho, U, phi)
)
);
phi = (fvc::interpolate(rho0 - psi*p0)/fvc::interpolate(psi))*phid;
fvScalarMatrix pEqn
(
fvm::ddt(psi, p)
+ fvc::div(phi)
+ fvm::div(phid, p)
- fvm::laplacian(rho*rUA, p)
);
pEqn.solve();
phi += pEqn.flux();
#include "compressibleContinuityErrs.H"
U -= rUA*fvc::grad(p);
U.correctBoundaryConditions();
}
// rhoU = ( rho*U.component(0) ) * (mesh.Sf()); // fvc::snGrad(fvc::reconstruct(phi)); // fvc::reconstruct(phi);
runTime.write();
// #include "binMassFluxNew.H"
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "readThermodynamicProperties.H"
#include "readTransportProperties.H"
#include "createFields.H"
#include "initContinuityErrs.H"
pimpleControl pimple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readTimeControls.H"
#include "compressibleCourantNo.H"
#include "rhoEqn.H"
// --- Pressure-velocity PIMPLE corrector loop
while (pimple.loop())
{
fvVectorMatrix UEqn
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
- fvm::laplacian(mu, U)
);
solve(UEqn == -fvc::grad(p));
// --- Pressure corrector loop
while (pimple.correct())
{
volScalarField rAU(1.0/UEqn.A());
U = rAU*UEqn.H();
surfaceScalarField phid
(
"phid",
psi
*(
(fvc::interpolate(U) & mesh.Sf())
+ fvc::ddtPhiCorr(rAU, rho, U, phi)
)
);
phi = (rhoO/psi)*phid;
volScalarField Dp("Dp", rho*rAU);
fvScalarMatrix pEqn
(
fvm::ddt(psi, p)
+ fvc::div(phi)
+ fvm::div(phid, p)
- fvm::laplacian(Dp, p)
);
pEqn.solve();
phi += pEqn.flux();
#include "compressibleContinuityErrs.H"
U -= rAU*fvc::grad(p);
U.correctBoundaryConditions();
}
}
rho = rhoO + psi*p;
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
//---------------------------------------------------------------------------
void fun_pEqn( const fvMeshHolder& mesh,
const TimeHolder& runTime,
const pimpleControlHolder& pimple,
basicPsiThermoHolder& thermo,
volScalarFieldHolder& rho,
volScalarFieldHolder& p,
volScalarFieldHolder& h,
volScalarFieldHolder& psi,
volVectorFieldHolder& U,
surfaceScalarFieldHolder& phi,
compressible::turbulenceModelHolder& turbulence,
fvVectorMatrixHolder& UEqn,
MRFZonesHolder& mrfZones,
volScalarFieldHolder& DpDt,
scalar& cumulativeContErr,
int& corr,
dimensionedScalar& rhoMax,
dimensionedScalar& rhoMin )
{
rho = thermo->rho();
rho = max( rho(), rhoMin );
rho = min( rho(), rhoMax );
rho->relax();
smart_tmp< volScalarField > rAU( 1.0 / UEqn->A() );
U = rAU() * UEqn->H();
if (pimple->nCorr() <= 1)
{
//UEqn->clear();
}
if (pimple->transonic())
{
surfaceScalarField phid( "phid", fvc::interpolate( psi() ) * ( ( fvc::interpolate( U() ) & mesh->Sf() )
+ fvc::ddtPhiCorr( rAU(), rho(), U(), phi() ) ) );
mrfZones->relativeFlux( fvc::interpolate( psi() ), phid);
for (int nonOrth=0; nonOrth <= pimple->nNonOrthCorr(); nonOrth++ )
{
smart_tmp< fvScalarMatrix > pEqn( fvm::ddt( psi(), p() ) + fvm::div( phid, p() ) - fvm::laplacian( rho() * rAU(), p() ) );
pEqn->solve( mesh->solver( p->select( pimple->finalInnerIter( corr, nonOrth ) ) ) );
if ( nonOrth == pimple->nNonOrthCorr() )
{
phi == pEqn->flux();
}
}
}
else
{
phi = fvc::interpolate( rho() ) * ( ( fvc::interpolate( U() ) & mesh->Sf() ) + fvc::ddtPhiCorr( rAU(), rho(), U(), phi() ) );
mrfZones->relativeFlux( fvc::interpolate( rho() ), phi() );
for (int nonOrth=0; nonOrth<=pimple->nNonOrthCorr(); nonOrth++)
{
// Pressure corrector
smart_tmp< fvScalarMatrix > pEqn( fvm::ddt( psi(), p() ) + fvc::div( phi() ) - fvm::laplacian( rho()*rAU(), p() ) );
pEqn->solve( mesh->solver( p->select( pimple->finalInnerIter( corr, nonOrth ) ) ) );
if ( nonOrth == pimple->nNonOrthCorr() )
{
phi += pEqn->flux();
}
}
}
rhoEqn( rho, phi );
compressibleContinuityErrs( thermo, rho, cumulativeContErr );
// Explicitly relax pressure for momentum corrector
p->relax();
// Recalculate density from the relaxed pressure
rho = thermo->rho();
rho = max( rho(), rhoMin );
rho = min( rho(), rhoMax );
rho->relax();
Info<< "rho max/min : " << max( rho() ).value() << " " << min( rho() ).value() << endl;
U -= rAU() * fvc::grad( p() );
U->correctBoundaryConditions();
DpDt = fvc::DDt(surfaceScalarField("phiU", phi() / fvc::interpolate( rho() ) ), p());
}
void kinematicSingleLayer::solveThickness
(
const volScalarField& pu,
const volScalarField& pp,
const fvVectorMatrix& UEqn
)
{
if (debug)
{
InfoInFunction << endl;
}
volScalarField rUA(1.0/UEqn.A());
U_ = rUA*UEqn.H();
surfaceScalarField deltarUAf(fvc::interpolate(delta_*rUA));
surfaceScalarField rhof(fvc::interpolate(rho_));
surfaceScalarField phiAdd
(
"phiAdd",
regionMesh().magSf()
* (
fvc::snGrad(pu, "snGrad(p)")
+ fvc::snGrad(pp, "snGrad(p)")*fvc::interpolate(delta_)
)
- fvc::flux(rho_*gTan())
);
constrainFilmField(phiAdd, 0.0);
surfaceScalarField phid
(
"phid",
fvc::flux(U_*rho_) - deltarUAf*phiAdd*rhof
);
constrainFilmField(phid, 0.0);
surfaceScalarField ddrhorUAppf
(
"deltaCoeff",
fvc::interpolate(delta_)*deltarUAf*rhof*fvc::interpolate(pp)
);
regionMesh().setFluxRequired(delta_.name());
for (int nonOrth=0; nonOrth<=nNonOrthCorr_; nonOrth++)
{
// Film thickness equation
fvScalarMatrix deltaEqn
(
fvm::ddt(rho_, delta_)
+ fvm::div(phid, delta_)
- fvm::laplacian(ddrhorUAppf, delta_)
==
- rhoSp_
);
deltaEqn.solve();
if (nonOrth == nNonOrthCorr_)
{
phiAdd +=
fvc::interpolate(pp)
* fvc::snGrad(delta_)
* regionMesh().magSf();
phi_ == deltaEqn.flux();
}
}
// Bound film thickness by a minimum of zero
delta_.max(0.0);
// Update U field
U_ -= fvc::reconstruct(deltarUAf*phiAdd);
// Remove any patch-normal components of velocity
U_ -= nHat()*(nHat() & U_);
U_.correctBoundaryConditions();
// Continuity check
continuityCheck();
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "readThermodynamicProperties.H"
//#include "readTransportProperties.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// dimensionedScalar period = dimensionedScalar("period", dimensionSet(0,0,1,0,0,0,0), 0.22e-9);
//dimensionedScalar tRed = dimensionedScalar("tRed", dimensionSet(0,0,1,0,0,0,0), 2.16059e-12);
//% STARTING PERIOD
//dimensionedScalar P_S = dimensionedScalar("P_S", dimensionSet(0,0,1,0,0,0,0), 100* 2.16059e-12);
scalar P_S = 100; // *2.16059e-12;
//scalar P_S = 100*2.16059e-12;
//% END PERIOD
//dimensionedScalar P_E = dimensionedScalar("P_E", dimensionSet(0,0,1,0,0,0,0), 5000* 2.16059e-12);
scalar P_E = 5000; //*2.16059e-12;
//scalar P_E = 5000*2.16059e-12;
//dimensionedScalar endTime = dimensionedScalar("endTime", dimensionSet(0,0,1,0,0,0,0), 10000* 2.16059e-12);
scalar endTime = 10000; //*2.16059e-12;
//scalar endTime = 10000*2.16059e-12;
// QUICKER TO BEGIN WITH AND HIGHER ORDER POLYNOMIAL
scalar n = 30; //*2.16059e-12;
//dimensionedScalar phase = 0;
scalar phase = 0;
//scalar period = 0;
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readPISOControls.H"
#include "compressibleCourantNo.H"
#include "rhoEqn.H"
scalar T = runTime.time().value() / 2.16059e-12;
scalar temp = ( Foam::pow(( (T - endTime)/endTime), n));
Info << "temp = " << temp << endl;
// dimensionedScalar freq = dimensionedScalar("freq", dimensionSet(0,0,-1,0,0,0,0), 0);
scalar freq= ((1/P_E) - ( ( (1/P_E) - (1/P_S) ) * temp )) /2.16059e-12 ;
// dimensionedScalar period = dimensionedScalar("period", dimensionSet(0,0,1,0,0,0,0), 1/freq);
// dimensionedScalar period = 1/freq;
scalar period = 1/freq;
// phase += (freq * runTime.deltaT().value()/2.16059e-12) ; // 0.0025*2.16059e-12;
Info << "phase = " << phase << endl;
phase += ((freq) * runTime.deltaT().value()) ; // 0.0025*2.16059e-12;
Info << "freq = " << freq << endl;
Info << "phase = " << phase << endl;
Info << "period = " << period << endl;
extForceField = extForce * rho / molMass * Foam::sin(2*3.1415*phase); // *phase) ;
fvVectorMatrix UEqn
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
- fvm::laplacian(mu, U)
- extForceField
);
solve(UEqn == -fvc::grad(p));
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
psi = (a0*pow(p,10) + a1*pow(p,9) + a2*pow(p,8) + a3*pow(p,7) + a4*pow(p,6) + a5*pow(p,5)
+ a6*pow(p,4) + a7*pow(p,3) + a8*pow(p,2) + a9*p + a10)/p;
rho = psi*(p);
mu = mu6 * pow(rho,6) + mu5 * pow(rho,5) + mu4 * pow(rho,4) + mu3 * pow(rho,3) + mu2 * pow(rho,2) + mu1 * rho + mu0;
volScalarField rUA = 1.0/UEqn.A();
U = rUA*UEqn.H();
surfaceScalarField phid
(
"phid",
fvc::interpolate(psi)
*(
(fvc::interpolate(U) & mesh.Sf())
+ fvc::ddtCorr(rho, U, phi)
//+ fvc::ddtPhiCorr(rUA, rho, U, phi)
)
);
phi = (fvc::interpolate(rho0 - psi*p0)/fvc::interpolate(psi))*phid;
fvScalarMatrix pEqn
(
fvm::ddt(psi, p)
+ fvc::div(phi)
+ fvm::div(phid, p)
- fvm::laplacian(rho*rUA, p)
);
pEqn.solve();
phi += pEqn.flux();
#include "compressibleContinuityErrs.H"
U -= rUA*fvc::grad(p);
U.correctBoundaryConditions();
}
// rhoU = ( rho*U.component(0) ) * (mesh.Sf()); // fvc::snGrad(fvc::reconstruct(phi)); // fvc::reconstruct(phi);
runTime.write();
// #include "binMassFluxNew.H"
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "readThermodynamicProperties.H"
// #include "readTransportProperties.H"
#include "createFields.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readPISOControls.H"
#include "compressibleCourantNo.H"
#include "rhoEqn.H"
fvVectorMatrix UEqn
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
- fvm::laplacian(mu, U)
);
solve(UEqn == -fvc::grad(p));
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
volScalarField rUA = 1.0/UEqn.A();
U = rUA*UEqn.H();
surfaceScalarField phid
(
"phid",
fvc::interpolate(psi)
*(
(fvc::interpolate(U) & mesh.Sf())
+ fvc::ddtPhiCorr(rUA, rho, U, phi)
)
);
phi = (fvc::interpolate(rho0 - psi*p0)/fvc::interpolate(psi))*phid;
fvScalarMatrix pEqn
(
fvm::ddt(psi, p)
+ fvc::div(phi)
+ fvm::div(phid, p)
- fvm::laplacian(rho*rUA, p)
);
pEqn.solve();
phi += pEqn.flux();
#include "compressibleContinuityErrs.H"
U -= rUA*fvc::grad(p);
U.correctBoundaryConditions();
}
// psi = (a0*pow(p,7) + b0*pow(p,6) + c0*pow(p,5) + d0*pow(p,4) + e0*pow(p,3) + f0*pow(p,2) + g0*p + h0) / (p) ;
// psi = (a0*pow(p,3) + b0*pow(p,2) + c0*p + d0) / (p - p0) ;
// rho = rho0 + psi*(p - p0);
// psi = (a0*log(p/b0)+c0)/(p);
// rho = psi*(p);
psi = (a0*pow(p,10) + a1*pow(p,9) + a2*pow(p,8) + a3*pow(p,7) + a4*pow(p,6) + a5*pow(p,5)
+ a6*pow(p,4) + a7*pow(p,3) + a8*pow(p,2) + a9*p + a10)/p;
rho = psi*(p);
mu = mu6 * pow(rho,6) + mu5 * pow(rho,5) + mu4 * pow(rho,4) + mu3 * pow(rho,3) + mu2 * pow(rho,2) + mu1 * rho + mu0;
// Info << "rho = " << rho << endl;
// Info << "psi = " << psi << endl;
//label patchID = mesh.boundaryMesh().findPatchID("walls");
//const polyPatch& cPatch = mesh.boundaryMesh()[patchID];
//vectorField nHat = cPatch.nf();
//vectorField gamma = (nHat & fvc::grad(U)().boundaryField()[patchID]) & (I - sqr(nHat));
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
pimpleControl pimple(mesh);
#include "readThermodynamicProperties.H"
// #include "readTransportProperties.H"
#include "createFields.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readTimeControls.H"
#include "compressibleCourantNo.H"
solve(fvm::ddt(rho) + fvc::div(phi));
// --- Pressure-velocity PIMPLE corrector loop
while (pimple.loop())
{
fvVectorMatrix UEqn
(
fvm::ddt(rho, U)
+ fvm::div(phi, U)
- fvm::laplacian(mu, U)
);
solve(UEqn == -fvc::grad(p));
// --- Pressure corrector loop
while (pimple.correct())
{
volScalarField rAU("rAU", 1.0/UEqn.A());
surfaceScalarField rhorAUf
(
"rhorAUf",
fvc::interpolate(rho*rAU)
);
U = rAU*UEqn.H();
surfaceScalarField phid
(
"phid",
fvc::interpolate(psi)//psi
*(
(fvc::interpolate(U) & mesh.Sf())
+ rhorAUf*fvc::ddtCorr(rho, U, phi)/fvc::interpolate(rho)
)
);
// phi = (rhoO/psi)*phid;
phi = (fvc::interpolate(rho0 - psi*p0)/fvc::interpolate(psi))*phid;
fvScalarMatrix pEqn
(
fvm::ddt(psi, p)
+ fvc::div(phi)
+ fvm::div(phid, p)
- fvm::laplacian(rhorAUf, p)
);
pEqn.solve();
phi += pEqn.flux();
solve(fvm::ddt(rho) + fvc::div(phi));
#include "compressibleContinuityErrs.H"
U -= rAU*fvc::grad(p);
U.correctBoundaryConditions();
}
}
// rho = rhoO + psi*p;
psi = (a0*pow(p,10) + a1*pow(p,9) + a2*pow(p,8) + a3*pow(p,7) + a4*pow(p,6) + a5*pow(p,5)
+ a6*pow(p,4) + a7*pow(p,3) + a8*pow(p,2) + a9*p + a10)/p;
rho = psi*(p);
mu = mu6 * pow(rho,6) + mu5 * pow(rho,5) + mu4 * pow(rho,4) + mu3 * pow(rho,3)
+ mu2 * pow(rho,2) + mu1 * rho + mu0;
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
