[mostanad]

Dear FOAMERS,
I hope you are all doing well. I have a general question about PIMPLE algorithm thta might be a bit silly!
Supposing that we have a temporal term like .
If I use PIMPLE and there would be nOuterCorrectors>1, in the temporal disctritization by is the previous timestep value, or the value of previous Outercorrector iteration? As I knwo, in the temporal discritization, we always consider this as rho.oldTime(). What does this oldTime() return in PIMPLE?

[ErenC]

Time marches after you reach the maximum number of outerIterations. You can see that in your log (or terminal).

[mostanad]

Originally Posted by ErenC

Time marches after you reach the maximum number of outerIterations. You can see that in your log (or terminal).

I dont have an actual case to see it now. About the theory, you mean time marching happens in the last outerIteration. And what about the iterations up to that? What value is used?

[Tobermory]

This has been quite an interesting rabbit hole to dive down - the "simplest" questions in OF often are! TLDR: the oldTime() value in a pimple loop is the solution from the last full solver iteration, ie does not change during the pimple loops (which essentially is what Eren was saying above).

Want the proof? Here is my attempt. Using rhoPimpleFoam from OF8 as a solver (I assume you are using a compressible pimple solver, from your discussion of drho/dt), we can see the pimple looping part of the code as:

         while (pimple.loop())
         {
                 .... update rho, U*, E, p & U, turb
         }

and if you dive into pimpleControl::loop() you'll find:

bool Foam::pimpleControl::loop()
 {
     read();
     if (!pimpleLoop::loop(*this))
     {
         updateFinal();
         return false;
     }
     storePrevIterFields();
     updateFinal();
     return true;
 }

where read() reads the solver controls from fvSolution, pimpleLoop::loop() checks to see if we are converged yet and does some admin, and updateFinal() flags whether this is the final pimple iteration or not. Note however the call to storePrevIterFields() for all but the final pimple loop - as the name suggests, this stores the previous pimple iter solution for the new time level (but only if relaxation is being applied to the field ... otherwise why would you want to store it?):

 template<class Type>
 void Foam::singleRegionSolutionControl::storePrevIterTypeFields() const
 {
     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
     HashTable<fieldType*>
         flds(mesh_.objectRegistry::lookupClass<fieldType>());
 
     forAllIter(typename HashTable<fieldType*>, flds, iter)
     {
         fieldType& fld = *iter();
         const word& fName = fld.name();
         size_t prevIterField = fName.find("PrevIter");
         if (prevIterField == word::npos && mesh_.relaxField(fName))
         {
             fld.storePrevIter();
         }
     }
 }

But what about the oldTime data? That is really tricky to find quickly, and in the end the following post threw some light on it for me: When does OpenFOAM execute "storeOldTime" ?. As is so common, OF does something really efficient and clever (and really difficult to parse initially!) and only stores oldTime when it needs to, i.e. when it is called. Essentially, a call to GeometricField:ldTime() returns the oldTime data, but first either creates an empty oldTime field if the field doesn't already exist (very first time step of a simulation?) or calls storeOldTimes():

 template<class Type, template<class> class PatchField, class GeoMesh>
 const Foam::GeometricField<Type, PatchField, GeoMesh>&
 Foam::GeometricField<Type, PatchField, GeoMesh>::oldTime() const
 {
     if (!field0Ptr_)
     {
         field0Ptr_ = new GeometricField<Type, PatchField, GeoMesh>
         (
             IOobject
             (
                 this->name() + "_0",
                 this->time().timeName(),
                 this->db(),
                 IOobject::NO_READ,
                 IOobject::NO_WRITE,
                 this->registerObject()
             ),
             *this
         );
     }
     else
     {
         storeOldTimes();
     }
 
     return *field0Ptr_;
 }

Now we are getting close. GeometricField::storeOldTimes() is:

 template<class Type, template<class> class PatchField, class GeoMesh>
 void Foam::GeometricField<Type, PatchField, GeoMesh>::storeOldTimes() const
 {
     if
     (
         field0Ptr_
      && timeIndex_ != this->time().timeIndex()
      && !(
             this->name().size() > 2
          && this->name()(this->name().size()-2, 2) == "_0"
          )
     )
     {
         storeOldTime();
     }
 
     // Correct time index
     timeIndex_ = this->time().timeIndex();
 }

and here we see that the call to storeOldTime() is only made if the timeIndex is not the same as the current solution time. In other words, for the interim pimple iterations, where the solver time is unchanging, the oldTime fields are not updated!

Time for a coffee ...

[mostanad]

Originally Posted by Tobermory

Want the proof?
.
.
.
.
Time for a coffee ...

Wow. Thanks Tobermory for your enlightening reply.