int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" pimpleControl pimple(mesh); #include "createTimeControls.H" #include "createFields.H" #include "createMRF.H" #include "createFvOptions.H" #include "initContinuityErrs.H" turbulence->validate(); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { laminarTransport.correct(); turbulence->correct(); } } 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" #include "initContinuityErrs.H" #include "createFields.H" pimpleControl pimple(mesh); #include "createPrghCorrTypes.H" #include "correctPhi.H" #include "CourantNo.H" #include "setInitialrDeltaT.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; #include "setrDeltaT.H" // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "alphaControls.H" #define LTSSOLVE #include "alphaEqnSubCycle.H" #undef LTSSOLVE mixture.correct(); turbulence->correct(); #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } } 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" #include "createFields.H" #include "initContinuityErrs.H" pimpleControl pimple(mesh); Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; #include "rhoEqn.H" // --- Pressure-velocity PIMPLE corrector loop for (pimple.start(); pimple.loop(); pimple++) { if (pimple.nOuterCorr() != 1) { p.storePrevIter(); rho.storePrevIter(); } #include "UEqn.H" #include "hEqn.H" // --- PISO loop for (int corr=0; corr<pimple.nCorr(); corr++) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } 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" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "createFvOptions.H" #include "initContinuityErrs.H" #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; #include "rhoEqn.H" while (pimple.loop()) { #include "UEqn.H" #include "YEqn.H" #include "EEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } 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 "createControls.H" #include "createFields.H" #include "CourantNo.H" #include "setInitialDeltaT.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readControls.H" #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "rhoEqn.H" #include "alphavPsi.H" #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } 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" #include "initContinuityErrs.H" #include "createFields.H" pimpleControl pimple(mesh); #include "correctPhi.H" #include "CourantNo.H" #include "setInitialrDeltaT.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; #include "setrDeltaT.H" twoPhaseProperties.correct(); #include "alphaEqnSubCycle.H" turbulence->correct(); // --- Pressure-velocity PIMPLE corrector loop for (pimple.start(); pimple.loop(); pimple++) { #include "UEqn.H" // --- PISO loop for (int corr=0; corr<pimple.nCorr(); corr++) { #include "pEqn.H" } } 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" #include "readChemistryProperties.H" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "createClouds.H" #include "createSurfaceFilmModel.H" #include "createPyrolysisModel.H" #include "createRadiationModel.H" #include "initContinuityErrs.H" #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" #include "readPyrolysisTimeControls.H" pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "solidRegionDiffusionNo.H" #include "setMultiRegionDeltaT.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; parcels.evolve(); surfaceFilm.evolve(); pyrolysis->evolve(); if (solvePrimaryRegion) { #include "rhoEqn.H" // --- PIMPLE loop for (pimple.start(); pimple.loop(); pimple++) { #include "UEqn.H" #include "YhsEqn.H" // --- PISO loop for (int corr=1; corr<=pimple.nCorr(); corr++) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } rho = thermo.rho(); } runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } Info<< "End" << endl; return(0); }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "createMRFZones.H" #include "createFvOptions.H" #include "initContinuityErrs.H" #include "readTimeControls.H" #include "CourantNos.H" #include "setInitialDeltaT.H" pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "CourantNos.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { fluid.solve(); fluid.correct(); volScalarField contErr1 ( fvc::ddt(alpha1, rho1) + fvc::div(alphaRhoPhi1) - (fvOptions(alpha1, rho1)&rho1) ); volScalarField contErr2 ( fvc::ddt(alpha2, rho2) + fvc::div(alphaRhoPhi2) - (fvOptions(alpha2, rho2)&rho2) ); #include "UEqns.H" //~ #include "EEqns.H" thermo1.correct(); thermo2.correct(); // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } #include "DDtU.H" if (pimple.turbCorr()) { fluid.correctTurbulence(); } } #include "write.H" Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" << endl; } Info<< "End\n" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" #include "readGravitationalAcceleration.H" #include "initContinuityErrs.H" #include "createFields.H" #include "readTimeControls.H" #include "CourantNo.H" #include "setInitialDeltaT.H" pimpleControl pimple(mesh); #include "correctPhi.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "CourantNo.H" #include "alphaCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; threePhaseProperties.correct(); #include "alphaEqnsSubCycle.H" #define twoPhaseProperties threePhaseProperties // --- Pressure-velocity PIMPLE corrector loop for (pimple.start(); pimple.loop(); pimple++) { #include "UEqn.H" // --- PISO loop for (int corr=0; corr<pimple.nCorr(); corr++) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } #include "continuityErrs.H" runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } Info<< "\n end \n"; return(0); }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createDynamicFvMesh.H" #include "initContinuityErrs.H" pimpleControl pimple(mesh); #include "createFields.H" #include "createUf.H" #include "createControls.H" #include "CourantNo.H" #include "setInitialDeltaT.H" turbulence->validate(); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readControls.H" { // Store divU from the previous mesh so that it can be mapped // and used in correctPhi to ensure the corrected phi has the // same divergence volScalarField divU("divU0", fvc::div(fvc::absolute(phi, U))); #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; scalar timeBeforeMeshUpdate = runTime.elapsedCpuTime(); // Do any mesh changes mesh.update(); if (mesh.changing()) { Info<< "Execution time for mesh.update() = " << runTime.elapsedCpuTime() - timeBeforeMeshUpdate << " s" << endl; gh = (g & mesh.C()) - ghRef; ghf = (g & mesh.Cf()) - ghRef; } if (mesh.changing() && correctPhi) { // Calculate absolute flux from the mapped surface velocity phi = mesh.Sf() & Uf; #include "correctPhi.H" // Make the fluxes relative to the mesh motion fvc::makeRelative(phi, U); } } if (mesh.changing() && checkMeshCourantNo) { #include "meshCourantNo.H" } turbulence->correct(); // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "alphaEqnsSubCycle.H" // correct interface on first PIMPLE corrector if (pimple.corr() == 1) { interface.correct(); } solve(fvm::ddt(rho) + fvc::div(rhoPhi)); #include "UEqn.H" #include "TEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } } rho = alpha1*rho1 + alpha2*rho2; runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" << endl; } Info<< "End\n" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" // #include "readGravitationalAcceleration.H" #include "createFields.H" #include "initContinuityErrs.H" #include "CourantNo.H" pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "CourantNos.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; thermo.update(); Q = Q0*(scalar(1)-Foam::exp(-runTime.value()/tau.value())); // Q = Q0; #if 0 if ((runTime.value() <= scalar(20.e-3)) && (runTime.value() >= scalar(0.1e-3)) ) { // Q = Q0*(scalar(1)-Foam::exp(-runTime.value()/tau.value())); // Ã tester : sans rampe Q = Q0; } else { Q = 0.0*Q; } //Q = Q0; #endif Info << " max(T) = " << max(T).value() << " K" << nl << endl; Info << " Puissance de flux (watt) = " << Q.value() <<" sur " << Q0.value() << " W" << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { volScalarField magW ("magW", magSqr(Un-Us)); gamma = 0.5*(fvc::ddt(rhon)+fvc::div(phin)-fvc::ddt(rhos)-fvc::div(phis)); continuity = (fvc::ddt(rhon)+fvc::div(phin) + fvc::ddt(rhos)+ fvc::div(phis)); #include "TEqn.H" #include "UEqns.H" // --- PISO loop while (pimple.correct()) { #include "pEqn.H" } } runTime.write(); if(runTime.outputTime()) { volVectorField GM ("GM", A*rhon*rhos*magSqr(Un-Us)*(Un-Us)); GM.write(); } Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } Info<< "End\n" << endl; return 0; }
int main(int argc, char *argv[]) { argList::addOption ( "cloudName", "name", "specify alternative cloud name. default is 'kinematicCloud'" ); #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" pimpleControl pimple(mesh); #include "createTimeControls.H" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "initContinuityErrs.H" Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; continuousPhaseTransport.correct(); muc = rhoc*continuousPhaseTransport.nu(); Info<< "Evolving " << kinematicCloud.name() << endl; kinematicCloud.evolve(); // Update continuous phase volume fraction field alphac = max(1.0 - kinematicCloud.theta(), alphacMin); alphac.correctBoundaryConditions(); alphacf = fvc::interpolate(alphac); alphaPhic = alphacf*phic; fvVectorMatrix cloudSU(kinematicCloud.SU(Uc)); volVectorField cloudVolSUSu ( IOobject ( "cloudVolSUSu", runTime.timeName(), mesh ), mesh, dimensionedVector ( "0", cloudSU.dimensions()/dimVolume, vector::zero ), zeroGradientFvPatchVectorField::typeName ); cloudVolSUSu.internalField() = -cloudSU.source()/mesh.V(); cloudVolSUSu.correctBoundaryConditions(); cloudSU.source() = vector::zero; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UcEqn.H" // --- PISO loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { continuousPhaseTurbulence->correct(); } } 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 "createDynamicFvMesh.H" pimpleControl pimple(mesh); #include "createFields.H" #include "readTimeControls.H" bool checkMeshCourantNo = readBool(pimple.dict().lookup("checkMeshCourantNo")); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // #include "initContinuityErrs.H" #include "readCourantType.H" dimensionedScalar v_zero("v_zero", dimVolume/dimTime, 0.0); Info<< "\nStarting time loop\n" << endl; #include "createSurfaceFields.H" #include "markBadQualityCells.H" while (runTime.run()) { #include "acousticCourantNo.H" #include "compressibleCourantNo.H" #include "readTimeControls.H" #include "setDeltaT.H" runTime++; psi.oldTime(); rho.oldTime(); p.oldTime(); U.oldTime(); h.oldTime(); Info<< "Time = " << runTime.timeName() << nl << endl; // --- Move mesh and update fluxes { // Do any mesh changes mesh.update(); if (mesh.changing()) { if (runTime.timeIndex() > 1) { surfaceScalarField amNew = min(min(phiv_pos - fvc::meshPhi(rho,U) - cSf_pos, phiv_neg - fvc::meshPhi(rho,U) - cSf_neg), v_zero); phiNeg += kappa*(amNew - am)*p_neg*psi_neg; phiPos += (1.0 - kappa)*(amNew - am)*p_neg*psi_neg; } else { phiNeg -= fvc::meshPhi(rho,U) * fvc::interpolate(rho); } phi = phiPos + phiNeg; if (checkMeshCourantNo) { #include "meshCourantNo.H" } #include "markBadQualityCells.H" } } // --- Solve density solve ( fvm::ddt(rho) + fvc::div(phi) ); Info<< "rhoEqn max/min : " << max(rho).value() << " " << min(rho).value() << endl; // --- Solve momentum #include "UEqn.H" // --- Solve energy #include "hEqn.H" // --- Solve pressure (PISO) { while (pimple.correct()) { #include "pEqnDyM.H" } #include "updateKappa.H" } // --- Solve turbulence turbulence->correct(); Ek = 0.5*magSqr(U); EkChange = fvc::ddt(rho,Ek) + fvc::div(phiPos,Ek) + fvc::div(phiNeg,Ek); dpdt = fvc::ddt(p) - fvc::div(fvc::meshPhi(rho,U), p); 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" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "createMRFZones.H" #include "createFvOptions.H" #include "initContinuityErrs.H" #include "readTimeControls.H" #include "CourantNos.H" #include "setInitialDeltaT.H" //for testing only with a constant interpahse mass transfer term dimensionedScalar gamma_LV ("gamma_LV", dimensionSet (1,-3,-1,0,0,0,0), scalar(0.000)); dimensionedScalar gamma_VL ("gamma_LV", dimensionSet (1,-3,-1,0,0,0,0), scalar(0.000)); // pipeline dimension dimensionedScalar Dh ("Dh", dimensionSet (0,1,0,0,0,0,0), scalar(0.233)); // initial wall temperature dimensionedScalar TwallInit ("TwallInit", dimensionSet (0,0,0,1,0,0,0), scalar(289.43)); // friction factor scalar frictionFactor = 0.005; //my volScalarField declaration #include "myVolScalar.H" //quasi-one-dimensional flow setup #include "changeArea.H" //load refprop thermodynamic library #include "refpropLibLoading.H" //initialise the wall temperature Twall = TwallInit; //dummy vector vector unity(1,0,0); //start of the loop pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "CourantNos.H" #include "setDeltaT.H" // interface mass and heat transfer #include "massAndEnergyTransfer.H" // update boundary conditions (NSCBC) #include "NSCBCpuncture.H" // update wall flux (heat transfer to the vapour phase from the wall) #include "transportProperties.H" // runtime time output runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { fluid.solve(); fluid.correct(); // interface mass and heat transfer //#include "massAndEnergyTransfer.H" // update boundary conditions p.boundaryField()[patchID] == p_ghost_update2; U1.boundaryField()[patchID] == vector(U_ghost_update2,0,0); U2.boundaryField()[patchID] == vector(U_ghost_update2,0,0); //thermo1.T().boundaryField()[patchID] == T_ghost_update; //thermo2.T().boundaryField()[patchID] == T_ghost_update; //alpha1.boundaryField()[patchID] == alpha1_ghost_update; //alpha2.boundaryField()[patchID] == 1.0 - alpha1_ghost_update; U_bulk = mag(alpha1*U1+alpha2*U2); rho_bulk = alpha1*rho1+alpha2*rho2; psi_bulk =1.0/(alpha1/thermo1.psi()+alpha2/thermo2.psi()); volScalarField contErr1 ( fvc::ddt(alpha1, rho1) + fvc::div(alphaRhoPhi1) - (fvOptions(alpha1, rho1)&rho1) // fvOptions are the runtime semi-implicit source term + alpha1*rho1*mag(U1)*areaSource - gammaV ); volScalarField contErr2 ( fvc::ddt(alpha2, rho2) + fvc::div(alphaRhoPhi2) - (fvOptions(alpha2, rho2)&rho2) + alpha2*rho2*mag(U2)*areaSource - gammaL ); // update friction source term Fv = - scalar(2)*frictionFactor*alpha1*rho1*mag(U1)*mag(U1)/Dh; Fl = - scalar(2)*frictionFactor*alpha2*rho2*mag(U2)*mag(U2)/Dh; #include "UEqns.H" // update friction source term for energy balance U_bulk = mag(alpha1*U1+alpha2*U2); FvU_bulk = U_bulk*Fv; FlU_bulk = U_bulk*Fl; #include "EEqns.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } #include "DDtU.H" if (pimple.turbCorr()) { fluid.correctTurbulence(); } } #include "write.H" //const volScalarField& test = alpha1_.db().lookupObject<volScalarField>("flowAreaGrad"); //loop over all cells: //forAll(mesh.C(), cellI) //{ //Info << "******* CellID: " << cellI << "*******"<< endl; //Getting list of all faces of current cell //const labelList& faces = mesh.cells()[cellI]; //loop over all faces of current cell //forAll( faces, faceI ) //{ //if (mesh.isInternalFace(faces[faceI])) //{ //Info << "internal faceI: " << faceI << " mesh.Sf()[faceI]: " << -mesh.Sf()[faceI] << " mesh.magSf()[faceI]: " << mesh.magSf()[faceI] << endl; //} //else //{ //Info << "boundary faceI: " << faceI << " mesh.Sf()[faceI]: " << -mesh.Sf()[faceI] << " mesh.magSf()[faceI]: " << mesh.magSf()[faceI] << endl; //} //} //move on to next face //Info << " " << endl; //}//move on to next cell Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" << endl; } Info<< "End\n" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" double t0 = runTime.startTime().value(); double dt = runTime.deltaT().value(); #include "createDynamicFvMesh.H" // motion solver is initialized here #include "initContinuityErrs.H" pimpleControl pimple(mesh); #include "createFields.H" #include "createUf.H" #include "createFvOptions.H" #include "readTimeControls.H" #include "createPcorrTypes.H" #include "CourantNo.H" #include "setInitialDeltaT.H" #include "readCouplingProperties.H" // for BeamDyn coupling, calls BD::readInputs() // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // BD::start( t0, dt ); // calculate shape functions once and for all at all surface nodes where // we will need to interpolate the beam displacement solution label interfacePatchID = BD::interfacePatchID(); BD::calculateShapeFunctions( mesh.boundaryMesh()[interfacePatchID].localPoints() ); BD::calculateInitialDisplacementVectors( mesh.boundaryMesh()[interfacePatchID].localPoints() ); Info<< "\nStarting time loop\n" << endl; // PARALLEL DEBUG // int sleepFlag = 0; // while (sleepFlag==0) // sleep(5); while (runTime.run()) { #include "readControls.H" #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // Prescribe motion here for the deformation testing (SOWE2015) // if (!beamSolve) // { // BD::updatePrescribedDeflection( runTime.timeOutputValue() ); // } // Displacements are updated through the beamDynInterface boundary condition // Note: there should not be any displacement for the first time step Info<< "Performing mesh update" << endl; mesh.update(); if (fluidSolve) { // Calculate absolute flux from the mapped surface velocity phi = mesh.Sf() & Uf; if (mesh.changing() && correctPhi) { #include "correctPhi.H" } // Make the flux relative to the mesh motion fvc::makeRelative(phi, U); } if (mesh.changing() && checkMeshCourantNo) { #include "meshCourantNo.H" } if (fluidSolve) { // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } } //Info<< "Writing output" << endl; runTime.write(); // // additional fsi steps // if (beamSolve) { BD::updateSectionLoads( mesh, p, turbulence ); BD::update( runTime.timeOutputValue(), runTime.deltaT().value(), mesh ); BD::write( runTime.timeName(), runTime.outputTime() ); // (time string, output flag) } Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } BD::stop(); Info<< "\nEnd\n" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createEngineTime.H" #include "createEngineMesh.H" pimpleControl pimple(mesh); #include "readCombustionProperties.H" #include "createFields.H" #include "createMRF.H" #include "createFvOptions.H" #include "createRhoUf.H" #include "initContinuityErrs.H" #include "readEngineTimeControls.H" #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" #include "startSummary.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readEngineTimeControls.H" #include "compressibleCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Crank angle = " << runTime.theta() << " CA-deg" << endl; mesh.move(); #include "rhoEqn.H" // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" #include "ftEqn.H" #include "bEqn.H" #include "EauEqn.H" #include "EaEqn.H" if (!ign.ignited()) { thermo.heu() == thermo.he(); } // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } #include "logSummary.H" rho = thermo.rho(); 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" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "createClouds.H" #include "createRadiationModel.H" #include "initContinuityErrs.H" #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; rhoEffLagrangian = coalParcels.rhoEff() + limestoneParcels.rhoEff(); pDyn = 0.5*rho*magSqr(U); coalParcels.evolve(); limestoneParcels.evolve(); #include "rhoEqn.H" // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" #include "YEqn.H" #include "hsEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } rho = thermo.rho(); 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 "createFields.H" #include "createMRF.H" #include "createFvOptions.H" #include "createRadiationModel.H" #include "initContinuityErrs.H" #include "createTimeControls.H" #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" turbulence->validate(); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "createTimeControls.H" #include "compressibleCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; #include "rhoEqn.H" // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" #include "EEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } rho = thermo.rho(); populationBalance->solve(); 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 "createTimeControls.H" #include "createRDeltaT.H" #include "initContinuityErrs.H" #include "createFields.H" #include "createMRF.H" #include "createFvOptions.H" if (!LTS) { #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" if (LTS) { #include "setRDeltaT.H" } else { #include "compressibleCourantNo.H" #include "setDeltaT.H" } runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; if (pimple.nCorrPIMPLE() <= 1) { #include "rhoEqn.H" } // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" #include "EEqn.H" // --- Pressure corrector loop while (pimple.correct()) { if (pimple.consistent()) { #include "pcEqn.H" } else { #include "pEqn.H" } } if (pimple.turbCorr()) { turbulence->correct(); } } 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" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "createDivSchemeBlendingField.H" #include "createGradPd.H" #include "readTimeControls.H" #include "CourantNo.H" #include "setInitialDeltaT.H" //#include "findVerticalCellLevels.H" //#include "findVerticalFaceLevels.H" #include "findWindHeight.H" //#include "openCellStatisticsFiles.H" //#include "openFaceStatisticsFiles.H" //#include "openABLStatisticsFiles.H" #include "createAverageFields.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // Initialize FAST for each turbine Info << "Number of Turbines = " << turbfast.turbNum << endl; float tstep = runTime.deltaT().value(); for(int turbNo=0; turbNo<turbfast.turbNum; turbNo++) { if(Pstream::myProcNo() == turbNo) { fastinit_(tstep, turbNo); fastgetbldpos_(turbfast.bldptx[turbNo], turbfast.bldpty[turbNo], turbfast.bldptz[turbNo]); } turbfast.getBldPos(turbNo); } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info << nl << "Starting time loop\n" << endl; // Update boundary conditions before starting in case anything needs // updating, for example after using mapFields to interpolate initial // field. U.correctBoundaryConditions(); phi = linearInterpolate(U) & mesh.Sf(); T.correctBoundaryConditions(); p_rgh.correctBoundaryConditions(); turbulence->correct(); Rwall.correctBoundaryConditions(); qwall.correctBoundaryConditions(); while (runTime.loop()) { Info << "Time = " << runTime.timeName() << tab; Info << "Time Step = " << runTime.timeIndex() << endl; #include "readTimeControls.H" #include "CourantNo.H" #include "setDeltaT.H" #include "updateDivSchemeBlendingField.H" // --- Pressure-velocity PIMPLE corrector loop for (pimple.start(); pimple.loop(); pimple++) { if (pimple.nOuterCorr() != 1) { p_rgh.storePrevIter(); } for(int turbNo=0; turbNo<turbfast.turbNum; turbNo++) { turbfast.getWndVec(turbNo); if(Pstream::myProcNo() == turbNo) { fastread_(turbfast.uin[turbNo], turbfast.vin[turbNo], turbfast.win[turbNo]); fastrun_(); fastgetbldpos_(turbfast.bldptx[turbNo], turbfast.bldpty[turbNo], turbfast.bldptz[turbNo]); fastgetbldforce_(turbfast.bldfx[turbNo], turbfast.bldfy[turbNo], turbfast.bldfz[turbNo]); } turbfast.computeBodyForce(turbNo); } #include "UEqn.H" #include "TEqn.H" // --- Pressure corrector loop for (int corr=0; corr<pimple.nCorr(); corr++) { #include "pEqn.H" #include "TEqn.H" } // --- Compute the velocity flux divergence #include "computeDivergence.H" // --- Update the driving pressure gradient #include "correctGradPd.H" // --- Update the turbulence fields if (pimple.turbCorr()) { turbulence->correct(); } // --- Update the turbine array //turbines.update(); // --- Update the boundary momentum and // temperature flux conditions Rwall.correctBoundaryConditions(); qwall.correctBoundaryConditions(); } #include "computeAverageFields.H" // if (runTime.outputTime()) // { // #include "averageFields.H" // } // #include "statisticsCell.H" // #include "statisticsFace.H" // #include "statisticsABL.H" runTime.write(); #include "writeGradPd.H" Info << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } // terminate FAST for each turbine for(int turbNo=0; turbNo<turbfast.turbNum; turbNo++) { if(Pstream::myProcNo() == turbNo) { fastend_(); } } Info << "End" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" pimpleControl pimple(mesh); #include "createFields.H" #include "createMRFZones.H" #include "initContinuityErrs.H" #include "createTimeControls.H" #include "correctPhi.H" #include "CourantNo.H" #include "setInitialDeltaT.H" turbulence->validate(); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "createTimeControls.H" #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { turbulence->correct(); fluid.solve(); rho = fluid.rho(); #include "zonePhaseVolumes.H" //#include "TEqns.H" #include "UEqns.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } #include "DDtU.H" } runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" << endl; } Info<< "End\n" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createDynamicFvMesh.H" #include "initContinuityErrs.H" pimpleControl pimple(mesh); #include "createFields.H" #include "createMRF.H" #include "createFvOptions.H" #include "readTimeControls.H" volScalarField rAU ( IOobject ( "rAU", runTime.timeName(), mesh, IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE ), mesh, dimensionedScalar("rAUf", dimTime/rho.dimensions(), 1.0) ); #include "correctPhi.H" #include "createUf.H" #include "CourantNo.H" #include "setInitialDeltaT.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readControls.H" #include "CourantNo.H" #include "alphaCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { if (pimple.firstIter() || moveMeshOuterCorrectors) { scalar timeBeforeMeshUpdate = runTime.elapsedCpuTime(); mesh.update(); if (mesh.changing()) { Info<< "Execution time for mesh.update() = " << runTime.elapsedCpuTime() - timeBeforeMeshUpdate << " s" << endl; gh = (g & mesh.C()) - ghRef; ghf = (g & mesh.Cf()) - ghRef; } if (mesh.changing() && correctPhi) { // Calculate absolute flux from the mapped surface velocity phi = mesh.Sf() & Uf; #include "correctPhi.H" // Make the flux relative to the mesh motion fvc::makeRelative(phi, U); mixture.correct(); } if (mesh.changing() && checkMeshCourantNo) { #include "meshCourantNo.H" } } mixture.solve(); rho = mixture.rho(); #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } 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" #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; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" pimpleControl pimple(mesh); #include "initContinuityErrs.H" #include "readGravitationalAcceleration.H" #include "readWaveProperties.H" #include "createExternalWaveForcing.H" #include "createFields.H" #include "readTimeControls.H" #include "correctPhi.H" #include "CourantNo.H" #include "setInitialDeltaT.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "CourantNo.H" #include "alphaCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; externalWave->step(); twoPhaseProperties.correct(); #include "alphaEqnSubCycle.H" relaxing.correct(); // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } // Close down the external wave forcing in a nice manner externalWave->close(); Info<< "End\n" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "createFvOptions.H" #include "createClouds.H" #include "createRadiationModel.H" #include "createSurfaceFilmModel.H" #include "initContinuityErrs.H" #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" pimpleControl pimple(mesh); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setMultiRegionDeltaT.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; parcels.evolve(); surfaceFilm.evolve(); if (solvePrimaryRegion) { #include "rhoEqn.H" // --- PIMPLE loop while (pimple.loop()) { #include "UEqn.H" #include "YEqn.H" #include "EEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } rho = thermo.rho(); runTime.write(); } else { runTime.write(); } Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } Info<< "End" << endl; return(0); }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" pimpleControl pimple(mesh); #include "createTimeControls.H" #include "createRDeltaT.H" #include "initContinuityErrs.H" #include "createFields.H" autoPtr<translationalFrame> frameOfReference ( translationalFrame::New(mesh) ); frameOfReference->registerVelocity(U); #include "createMRF.H" #include "createFvOptions.H" #include "correctPhi.H" if (!LTS) { #include "readTimeControls.H" #include "CourantNo.H" #include "setInitialDeltaT.H" } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" if (LTS) { #include "setRDeltaT.H" } else { #include "CourantNo.H" #include "alphaCourantNo.H" #include "setDeltaT.H" } frameOfReference->update(p, turbulence->devReff()); runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "alphaControls.H" #include "alphaEqnSubCycle.H" mixture.correct(); #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } 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 "createDynamicFvMesh.H" #include "initContinuityErrs.H" pimpleControl pimple(mesh); #include "readThermodynamicProperties.H" #include "readControls.H" #include "createFields.H" #include "createUf.H" #include "createPcorrTypes.H" #include "CourantNo.H" #include "setInitialDeltaT.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readControls.H" { #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // Do any mesh changes mesh.update(); if (mesh.changing() && correctPhi) { // Calculate absolute flux from the mapped surface velocity phi = mesh.Sf() & Uf; #include "correctPhi.H" // Make the flux relative to the mesh motion fvc::makeRelative(phi, U); } } // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "rhoEqn.H" #include "alphavPsi.H" #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } 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[]) { argList args = setRootCase( argc, argv ); TimeHolder runTime=createTime( Time::controlDictName, args ); fvMeshHolder mesh = createMesh( runTime ); basicPsiThermoHolder pThermo; volScalarFieldHolder rho; volScalarFieldHolder p; volScalarFieldHolder h; volScalarFieldHolder psi; volVectorFieldHolder U; surfaceScalarFieldHolder phi; compressible::turbulenceModelHolder turbulence; volScalarFieldHolder DpDt; result_createFields result = createFields( runTime, mesh, pThermo, rho, p, h, psi, U, phi, turbulence, DpDt ); dimensionedScalar rhoMax = result.m_rhoMax; dimensionedScalar rhoMin = result.m_rhoMin; MRFZonesHolder mrfZones; porousZonesHolder pZones; Switch pressureImplicitPorosity; createZones( mesh, U, mrfZones, pZones, pressureImplicitPorosity ); scalar cumulativeContErr = initContinuityErrs(); pimpleControlHolder pimple(mesh); Info<< "\nStarting time loop\n" << endl; while (runTime->run()) { bool adjustTimeStep; scalar maxCo; scalar maxDeltaT; readTimeControls( runTime, adjustTimeStep, maxCo, maxDeltaT ); scalar coNum, meanCoNum; compressibleCourantNo( runTime, mesh, phi, rho, coNum, meanCoNum ); setDeltaT( runTime, adjustTimeStep, maxCo, coNum, maxDeltaT ); (*runTime)++; Info<< "Time = " << runTime->timeName() << nl << endl; rhoEqn( rho, phi ); // --- Pressure-velocity PIMPLE corrector loop for (pimple->start(); pimple->loop(); (*pimple)++) { if (pimple->nOuterCorr() != 1) { p->storePrevIter(); rho->storePrevIter(); } fvVectorMatrixHolder UEqn = fun_Ueqn( pimple, rho, p, U, phi, turbulence, mrfZones, pZones ); fun_hEqn( pThermo, rho, p, h, phi, turbulence, DpDt ); // --- PISO loop for (int corr=0; corr<pimple->nCorr(); corr++) { fun_pEqn( mesh, runTime, pimple, pThermo, rho, p, h, psi, U, phi, turbulence, UEqn, mrfZones, DpDt, cumulativeContErr, corr, rhoMax, rhoMin ); } if (pimple->turbCorr()) { turbulence->correct(); } } 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" #include "readCombustionProperties.H" #include "readGravitationalAcceleration.H" #include "createFields.H" #include "initContinuityErrs.H" #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setInitialDeltaT.H" pimpleControl pimple(mesh); scalar StCoNum = 0.0; // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "readTimeControls.H" #include "compressibleCourantNo.H" #include "setDeltaT.H" runTime++; Info<< "\n\nTime = " << runTime.timeName() << endl; #include "rhoEqn.H" // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "bEqn.H" #include "ftEqn.H" #include "EauEqn.H" #include "EaEqn.H" if (!ign.ignited()) { thermo.heu() == thermo.he(); } #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } runTime.write(); Info<< "\nExecutionTime = " << runTime.elapsedCpuTime() << " s\n" << endl; } Info<< "\n end\n"; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" pimpleControl pimple(mesh); #include "createFields.H" #include "createFvOptions.H" #include "createTimeControls.H" #include "CourantNo.H" #include "setInitialDeltaT.H" turbulence->validate(); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.run()) { #include "createTimeControls.H" #include "CourantNo.H" #include "setDeltaT.H" runTime++; Info<< "Time = " << runTime.timeName() << nl << endl; // --- Pressure-velocity PIMPLE corrector loop while (pimple.loop()) { #include "alphaControls.H" surfaceScalarField rhoPhi ( IOobject ( "rhoPhi", runTime.timeName(), mesh ), mesh, dimensionedScalar("0", dimMass/dimTime, 0) ); mixture->correct(); #include "alphaEqnSubCycle.H" interface.correct(); #include "UEqn.H" // --- Pressure corrector loop while (pimple.correct()) { #include "pEqn.H" } if (pimple.turbCorr()) { turbulence->correct(); } } runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } Info<< "End\n" << endl; return 0; }