1

Previous: Algorithms PISO and SIMPLE Up: Algorithms PISO and SIMPLE Next: SIMPLE

This is an automatically generated documentation by LaTeX2HTML utility. In case of any issue, please, contact us at info@cfdsupport.com.

PISO

  • Assume Navier-Stokes equations for incompressible fluid flow
  • Mass conservation equation (continuity equation)

    115(11.1)

  • Momentum conservation equation (velocity equation)

    117(11.2)
  • When discretized momentum conservation equation:

    118(11.3)
  • Matrix linear system:

    120(11.4)
  • Matrix 121 is diagonal, with diagonal of original matrix 122
  • 123 is vector corresponding to (crossref 3)
  • Rewriting (crossref 3) with substitution from (crossref 3):

    124(11.5)

  • Express 125 from equation (), i.e. momentum correction equation :

    126(11.6)

    crossref 3

  • We combine momentum correction equation (crossref 3) and continuity equation (crossref 3), which gives us:

    127(11.7)
  • PISO algorithm description:
  1. Computation starts, initial 128 and 129 are chosen
  2. Time step starts
  3. Boundary conditions are updated
  4. Linear system is solved 130
  5. Obtained new 128
  6. Building matrix 121 and vector 123
  7. Mass flow over cell faces is computed
  8. Pressure correction is applied (crossref 3)
  9. Obtained new 129
  10. Mass flow over cell faces is corrected
  11. Momentum correction is applied (crossref 3)
  12. Obtained new corrected 128
  13. Boundary conditions are updated
  14. Steps 6 – 13 are repeated with respect to nCorrectors value
  15. Time step ends
  • PISO algorithm in source code:
  • Take a look at solver icoFoam:
    # less $FOAM_SOLVERS/incompressible/icoFoam/icoFoam.C
     Info<< "\nStarting time loop\n" << endl;
    
  • At the beginning of the computation the output is : Starting time loop
        while (runTime.loop())
        {
            Info<< "Time = " << runTime.timeName() << nl << endl;
    
            #include "readPISOControls.H"
            #include "CourantNo.H"
    
  • Cycle over all time steps
  • Actual time layer is written on the output
  • Include header files
            fvVectorMatrix UEqn
            (
                fvm::ddt(U)
              + fvm::div(phi, U)
              - fvm::laplacian(nu, U)
            );
    
  • Momentum matrix 122 is created (UEqn)
  • UEqn is the left hand side of equation (crossref 3)
            solve(UEqn == -fvc::grad(p));
    
  • Solves system 131
            // --- PISO loop
    
            for (int corr=0; corr<nCorr; corr++)
            {
    
  • Start of PISO algorithm
  • Loop runs until the repetition reaches the value nCorrectors
                volScalarField rAU(1.0/UEqn.A());
    
  • The matrix 132 is saved as rAU
                volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p));
    
  • Evaluates relation 133 and saves to Hbya
               surfaceScalarField phiHbyA
                (
                    "phiHbyA",
                    fvc::flux(HbyA)
                  + fvc::interpolate(rAU)*fvc::ddtCorr(U, phi)
                );
    
                adjustPhi(phiHbyA, U, p);
    
                // Update the pressure BCs to ensure flux consistency
                constrainPressure(p, U, phiHbyA, rAU);
    
                // Non-orthogonal pressure corrector loop
                while (piso.correctNonOrthogonal())
                {
                    // Pressure corrector
    
                    fvScalarMatrix pEqn
                    (
                        fvm::laplacian(rAU, p) == fvc::div(phiHbyA)
                    );
    
                    pEqn.setReference(pRefCell, pRefValue);
    
                    pEqn.solve(mesh.solver(p.select(piso.finalInnerIter())));
    
  • Pressure correction loop solves equation crossref 3
                    if (piso.finalNonOrthogonalIter())
                    {
                        phi = phiHbyA - pEqn.flux();
                    }
                }
    
  • Momentum correction
                #include "continuityErrs.H"
    
  • Including header file for continuity error evaluation
                U = HbyA - rAU*fvc::grad(p);
                U.correctBoundaryConditions();    
            }
    
  • Momentum (velocity) correction
  • Boundary conditions correction
  • End of current time step
            runTime.write();
    
  • Writes data to disk (if it is in the time layer where it is told to write down)
            Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
                << "  ClockTime = " << runTime.elapsedClockTime() << " s"
                << nl << endl;
        }
    
        Info<< "End\n" << endl;
    
  • Writes time information
  • End of computation