time interpolate levelGhostParticles in IonUpdater

[nicolasaunai]

Context

Level ghost particles contributing to the moments have two origins:

• those refined from the next coarser at its former time step : LevelGhostParticlesOld
• those refined from the next coarser at its current time step : LevelGhostParticlesNew

when calculating the moments on a given level at an arbitrary time, let alpha be the ratio of the current time since the last level synchronisation time (next coarser former time step) and the total duration of the next coarser time step, then the contribution of the level ghost particles is :

alpha * levelGhostParticlesNew + (1-alpha) * levelGhostParticlesOld.

alpha being 0 before the first time step of the sub cycle, and 1 at the end of the sub cycle

In ion_updater.h we have :

double alpha = 0.5;
interpolator_(std::begin(pop.levelGhostParticlesNew()),
                      std::end(pop.levelGhostParticlesNew()), pop.density(), pop.flux(), layout,
                      /*coef = */ alpha);


interpolator_(std::begin(pop.levelGhostParticlesOld()),
                       std::end(pop.levelGhostParticlesOld()), pop.density(), pop.flux(), layout,
                       /*coef = */ (1. - alpha));

This means that for now, alpha is hard-coded to be 0.5.

Objective

This issue aims at getting alpha defined correctly, i.e. to be the current time elapsed since last sync point. divided by the total duration of the next coarser time step.

hint:

this is done in hybrid_hybrid_messenger_strategy.h

        double timeInterpCoef_(double const beforePushTime, double const afterPushTime)
        {
            return (afterPushTime - beforePushTime)
                   / (afterPushCoarseTime_ - beforePushCoarseTime_);
        }

and used in the same file:

        virtual void fillIonMomentGhosts(IonsT& ions, SAMRAI::hier::PatchLevel& level,
                                         double const beforePushTime,
                                         double const afterPushTime) override
        {
            auto alpha = timeInterpCoef_(beforePushTime, afterPushTime);


            for (auto patch : level)
            {
                auto dataOnPatch = resourcesManager_->setOnPatch(*patch, ions);
                auto layout      = layoutFromPatch<GridLayoutT>(*patch);

                for (auto& pop : ions)
                {
                    // first thing to do is to project patchGhostParitcles moments
                    auto& patchGhosts = pop.patchGhostParticles();
                    auto& density     = pop.density();
                    auto& flux        = pop.flux();

                    interpolate_(std::begin(patchGhosts), std::end(patchGhosts), density, flux,
                                 layout);


                    // then grab levelGhostParticlesOld and levelGhostParticlesNew
                    // and project them with alpha and (1-alpha) coefs, respectively
                    auto& levelGhostOld = pop.levelGhostParticlesOld();
                    interpolate_(std::begin(levelGhostOld), std::end(levelGhostOld), density, flux,
                                 layout, 1. - alpha);

                    auto& levelGhostNew = pop.levelGhostParticlesNew();
                    interpolate_(std::begin(levelGhostNew), std::end(levelGhostNew), density, flux,
                                 layout, alpha);
                }
            }
        }