MRISplitIntegrator< T > Class Template Reference

#include <ERF_MRI.H>

Collaboration diagram for MRISplitIntegrator< T >:

Public Member Functions
	MRISplitIntegrator ()=default
	MRISplitIntegrator (const T &S_data)
void	initialize (const T &S_data)
	~MRISplitIntegrator ()=default
	MRISplitIntegrator (MRISplitIntegrator &&) noexcept=default
MRISplitIntegrator &	operator= (MRISplitIntegrator &&other) noexcept=default
	MRISplitIntegrator (const MRISplitIntegrator &other)=delete
MRISplitIntegrator &	operator= (const MRISplitIntegrator &other)=delete
void	setNcompCons (int _ncomp_cons)
void	setAnelastic (int _anelastic)
void	setNoSubstepping (int _no_substepping)
void	setForceFirstStageSingleSubstep (int _force_stage1_single_substep)
void	set_slow_rhs_pre (std::function< void(T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)> F)
void	set_slow_rhs_inc (std::function< void(T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)> F)
void	set_slow_rhs_post (std::function< void(T &, T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)> F)
void	set_fast_rhs (std::function< void(int, int, int, T &, const T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const amrex::Real)> F)
void	set_slow_fast_timestep_ratio (const int timestep_ratio=1)
int	get_slow_fast_timestep_ratio ()
void	set_no_substep (std::function< void(T &, T &, T &, amrex::Real, amrex::Real, int)> F)
std::function< void(T &, const T &, const amrex::Real, int)>	get_rhs ()
amrex::Real	advance (T &S_old, T &S_new, amrex::Real time, const amrex::Real time_step)
void	map_data (std::function< void(T &)> Map)

Private Member Functions
void	initialize_data (const T &S_data)

Private Attributes
std::function< void(T &, const T &, const amrex::Real, const amrex::Real)>	rhs
	rhs is the right-hand-side function the integrator will use. More...
std::function< void(T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)>	slow_rhs_pre
std::function< void(T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)>	slow_rhs_inc
std::function< void(T &, T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)>	slow_rhs_post
std::function< void(int, int, int, T &, const T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const amrex::Real)>	fast_rhs
amrex::Real	timestep
	Integrator timestep size (Real) More...
int	slow_fast_timestep_ratio = 0
	The ratio of slow timestep size / fast timestep size (int) More...
int	no_substepping
	Should we not do acoustic substepping. More...
int	anelastic
	Should we use the anelastic integrator. More...
int	ncomp_cons
	How many components in the cell-centered MultiFab. More...
int	force_stage1_single_substep
	Do we follow the recommendation to only perform a single substep in the first RK stage. More...
std::function< void(T &, T &, T &, amrex::Real, amrex::Real, int)>	no_substep
	The no_substep function is called when we have no acoustic substepping. More...
amrex::Vector< std::unique_ptr< T > >	T_store
T *	S_sum
T *	S_scratch
T *	F_slow

Constructor & Destructor Documentation

MRISplitIntegrator() [1/4]

template<class T >

MRISplitIntegrator< T >::MRISplitIntegrator ( )

default

MRISplitIntegrator() [2/4]

template<class T >

MRISplitIntegrator< T >::MRISplitIntegrator ( const T &  S_data )

inline

    {
        initialize_data(S_data);
    }

Here is the call graph for this function:

~MRISplitIntegrator()

template<class T >

MRISplitIntegrator< T >::~MRISplitIntegrator ( )

default

MRISplitIntegrator() [3/4]

template<class T >

MRISplitIntegrator< T >::MRISplitIntegrator ( MRISplitIntegrator< T > &&  )

defaultnoexcept

MRISplitIntegrator() [4/4]

template<class T >

MRISplitIntegrator< T >::MRISplitIntegrator ( const MRISplitIntegrator< T > &  other )

delete

Member Function Documentation

advance()

template<class T >

amrex::Real MRISplitIntegrator< T >::advance ( T &  S_old, T &  S_new, amrex::Real  time, const amrex::Real  time_step  )

inline

    {
    BL_PROFILE_REGION("MRI_advance");
        using namespace amrex;
 
        // *******************************************************************************
        // !no_substepping: we only update the fast variables every fast timestep, then update
        //                  the slow variables after the acoustic sub-stepping.  This has
        //                  two calls to slow_rhs so that we can update the slow variables
        //                  with the velocity field after the acoustic substepping using
        //                  the time-averaged velocity from the substepping
        // no_substepping:  we don't do any acoustic subcyling so we only make one call per RK
        //                  stage to slow_rhs
        // *******************************************************************************
        timestep = time_step;
 
        const int substep_ratio = get_slow_fast_timestep_ratio();
 
        if (!no_substepping) {
            AMREX_ALWAYS_ASSERT(substep_ratio > 1 && substep_ratio % 2 == 0);
        }
 
        // Assume before advance() that S_old is valid data at the current time ("time" argument)
        // And that if data is a MultiFab, both S_old and S_new contain ghost cells for evaluating a stencil based RHS
        // We need this from S_old. This is convenient for S_new to have so we can use it
        // as scratch space for stage values without creating a new scratch MultiFab with ghost cells.
 
        // NOTE: In the following, we use S_new to hold S*, S**, and finally, S^(n+1) at the new time
        // DEFINITIONS:
        // S_old  = S^n
        // S_sum  = S(t)
        // F_slow = F(S_stage)
 
        int n_data = IntVars::NumTypes;
 
        /**********************************************/
        /* RK3 Integration with Acoustic Sub-stepping */
        /**********************************************/
        Vector<int> num_vars = {ncomp_cons, 1, 1, 1};
        for (int i(0); i<n_data; ++i)
        {
            // Copy old -> new
            MultiFab::Copy(S_new[i],S_old[i],0,0,num_vars[i],S_old[i].nGrowVect());
        }
 
        // Timestep taken by the fast integrator
        amrex::Real dtau;
 
        // How many timesteps taken by the fast integrator
        int nsubsteps;
 
        // This is the final time of the full timestep (also the 3rd RK stage)
        // Real new_time = time + timestep;
 
        amrex::Real time_stage = time;
        amrex::Real old_time_stage;
 
        const amrex::Real sub_timestep = timestep / substep_ratio;
 
        if (!anelastic) {
          // RK3 for compressible integrator
          for (int nrk = 0; nrk < 3; nrk++)
          {
            // Capture the time we got to in the previous RK step
            old_time_stage = time_stage;
 
            if (nrk == 0) {
                if (force_stage1_single_substep || no_substepping) {
                    nsubsteps = 1;               dtau = timestep / 3.0;
                } else {
                    nsubsteps = substep_ratio/3; dtau = sub_timestep  ;
                }
                time_stage = time + timestep / 3.0;
            }
            if (nrk == 1) {
                if (no_substepping) {
                    nsubsteps =               1; dtau = 0.5 * timestep;
                } else {
                    nsubsteps = substep_ratio/2; dtau =   sub_timestep;
                }
                time_stage = time + timestep / 2.0;
            }
            if (nrk == 2) {
                if (no_substepping) {
                    nsubsteps =             1;   dtau =     timestep;
                } else {
                    nsubsteps = substep_ratio;   dtau = sub_timestep;
 
                    // STRT HACK -- this hack can be used to approximate the no-substepping algorithm
                    // nsubsteps = 1;   dtau = timestep;
                    // END HACK
                }
                time_stage = time + timestep;
            }
 
            // step 1 starts with S_stage = S^n  and we always start substepping at the old time
            // step 2 starts with S_stage = S^*  and we always start substepping at the old time
            // step 3 starts with S_stage = S^** and we always start substepping at the old time
 
            // S_scratch also holds the average momenta over the fast iterations --
            //    to be used to update the slow variables -- we will initialize with
            //    the momenta used in the first call to the slow_rhs, then update
            //    inside fast_rhs, then use these values in the later call to slow_rhs
 
            slow_rhs_pre(*F_slow, S_old, S_new, *S_scratch, time, old_time_stage, time_stage, nrk);
 
            amrex::Real inv_fac = 1.0 / static_cast<amrex::Real>(nsubsteps);
 
            // ****************************************************
            // Acoustic substepping
            // ****************************************************
            if (!no_substepping)
            {
                // *******************************************************************************
                // Update the fast variables
                // *******************************************************************************
                for (int ks = 0; ks < nsubsteps; ++ks)
                {
                    fast_rhs(ks, nsubsteps, nrk, *F_slow, S_old, S_new, *S_sum, *S_scratch, dtau, inv_fac,
                             time + ks*dtau, time + (ks+1) * dtau);
 
                } // ks
 
            } else {
                no_substep(*S_sum, S_old, *F_slow, time + nsubsteps*dtau, nsubsteps*dtau, nrk);
            }
 
            // ****************************************************
            // Evaluate F_slow(S_stage) only for the slow variables
            // Note that we are using the current stage versions (in S_new) of the slow variables
            //      (because we didn't update the slow variables in the substepping)
            //       but we are using the "new" versions (in S_sum) of the velocities
            //      (because we did    update the fast variables in the substepping)
            // ****************************************************
            slow_rhs_post(*F_slow, S_old, S_new, *S_sum, *S_scratch, time, old_time_stage, time_stage, nrk);
          } // nrk
 
        } else {
          // RK2 for anelastic integrator
          for (int nrk = 0; nrk < 2; nrk++)
          {
            // Capture the time we got to in the previous RK step
            old_time_stage = time_stage;
 
            if (nrk == 0) { nsubsteps = 1; dtau = timestep; time_stage = time + timestep; }
            if (nrk == 1) { nsubsteps = 1; dtau = timestep; time_stage = time + timestep; }
 
            // S_scratch also holds the average momenta over the fast iterations --
            //    to be used to update the slow variables -- we will initialize with
            //    the momenta used in the first call to the slow_rhs, then update
            //    inside fast_rhs, then use these values in the later call to slow_rhs
 
            slow_rhs_inc(*F_slow, S_old, S_new, *S_scratch, time, old_time_stage, time_stage, nrk);
 
            no_substep(*S_sum, S_old, *F_slow, time + nsubsteps*dtau, nsubsteps*dtau, nrk);
 
            // ****************************************************
            // Evaluate F_slow(S_stage) only for the slow variables
            // Note that we are using the current stage versions (in S_new) of the slow variables
            //      (because we didn't update the slow variables in the substepping)
            //       but we are using the "new" versions (in S_sum) of the velocities
            //      (because we did    update the fast variables in the substepping)
            // ****************************************************
            slow_rhs_post(*F_slow, S_old, S_new, *S_sum, *S_scratch, time, old_time_stage, time_stage, nrk);
          } // nrk
        }
 
        // Return timestep
        return timestep;
    }

Referenced by ERF::advance_dycore().

Here is the call graph for this function:

Here is the caller graph for this function:

get_rhs()

template<class T >

std::function<void(T&, const T&, const amrex::Real, int)> MRISplitIntegrator< T >::get_rhs ( )

inline

    {
        return rhs;
    }

get_slow_fast_timestep_ratio()

template<class T >

int MRISplitIntegrator< T >::get_slow_fast_timestep_ratio ( )

inline

    {
        return slow_fast_timestep_ratio;
    }

Referenced by MRISplitIntegrator< T >::advance().

Here is the caller graph for this function:

initialize()

template<class T >

void MRISplitIntegrator< T >::initialize ( const T &  S_data )

inline

    {
        initialize_data(S_data);
    }

Here is the call graph for this function:

initialize_data()

template<class T >

void MRISplitIntegrator< T >::initialize_data ( const T &  S_data )

inlineprivate

    {
        // TODO: We can optimize memory by making the cell-centered part of S_sum, S_scratch
        //       have only 2 components, not ncomp_cons components
        const bool include_ghost = true;
        amrex::IntegratorOps<T>::CreateLike(T_store, S_data, include_ghost);
        S_sum = T_store[0].get();
        amrex::IntegratorOps<T>::CreateLike(T_store, S_data, include_ghost);
        S_scratch = T_store[1].get();
        amrex::IntegratorOps<T>::CreateLike(T_store, S_data, include_ghost);
        F_slow = T_store[2].get();
    }

Referenced by MRISplitIntegrator< T >::initialize(), and MRISplitIntegrator< T >::MRISplitIntegrator().

Here is the caller graph for this function:

map_data()

template<class T >

void MRISplitIntegrator< T >::map_data ( std::function< void(T &)>  Map )

inline

    {
        for (auto& F : T_store) {
            Map(*F);
        }
    }

operator=() [1/2]

template<class T >

MRISplitIntegrator& MRISplitIntegrator< T >::operator= ( const MRISplitIntegrator< T > &  other )

delete

operator=() [2/2]

template<class T >

MRISplitIntegrator& MRISplitIntegrator< T >::operator= ( MRISplitIntegrator< T > &&  other )

defaultnoexcept

set_fast_rhs()

template<class T >

void MRISplitIntegrator< T >::set_fast_rhs ( std::function< void(int, int, int, T &, const T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const amrex::Real)>  F )

inline

    {
        fast_rhs = F;
    }

Referenced by ERF::advance_dycore().

Here is the caller graph for this function:

set_no_substep()

template<class T >

void MRISplitIntegrator< T >::set_no_substep ( std::function< void(T &, T &, T &, amrex::Real, amrex::Real, int)>  F )

inline

    {
        no_substep = F;
    }

Referenced by ERF::advance_dycore().

Here is the caller graph for this function:

set_slow_fast_timestep_ratio()

template<class T >

void MRISplitIntegrator< T >::set_slow_fast_timestep_ratio ( const int  timestep_ratio = 1 )

inline

    {
        slow_fast_timestep_ratio = timestep_ratio;
    }

Referenced by ERF::advance_dycore().

Here is the caller graph for this function:

set_slow_rhs_inc()

template<class T >

void MRISplitIntegrator< T >::set_slow_rhs_inc ( std::function< void(T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)>  F )

inline

    {
        slow_rhs_inc = F;
    }

Referenced by ERF::advance_dycore().

Here is the caller graph for this function:

set_slow_rhs_post()

template<class T >

void MRISplitIntegrator< T >::set_slow_rhs_post ( std::function< void(T &, T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)>  F )

inline

    {
        slow_rhs_post = F;
    }

Referenced by ERF::advance_dycore().

Here is the caller graph for this function:

set_slow_rhs_pre()

template<class T >

void MRISplitIntegrator< T >::set_slow_rhs_pre ( std::function< void(T &, T &, T &, T &, const amrex::Real, const amrex::Real, const amrex::Real, const int)>  F )

inline

    {
        slow_rhs_pre = F;
    }

Referenced by ERF::advance_dycore().

Here is the caller graph for this function:

setAnelastic()

template<class T >

void MRISplitIntegrator< T >::setAnelastic ( int  _anelastic )

inline

    {
        anelastic = _anelastic;
    }

setForceFirstStageSingleSubstep()

template<class T >

void MRISplitIntegrator< T >::setForceFirstStageSingleSubstep ( int  _force_stage1_single_substep )

inline

    {
        force_stage1_single_substep = _force_stage1_single_substep;
    }

setNcompCons()

template<class T >

void MRISplitIntegrator< T >::setNcompCons ( int  _ncomp_cons )

inline

    {
        ncomp_cons = _ncomp_cons;
    }

setNoSubstepping()

template<class T >

void MRISplitIntegrator< T >::setNoSubstepping ( int  _no_substepping )

inline

    {
        no_substepping = _no_substepping;
    }

Member Data Documentation

anelastic

template<class T >

int MRISplitIntegrator< T >::anelastic

private

Should we use the anelastic integrator.

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::setAnelastic().

F_slow

template<class T >

T* MRISplitIntegrator< T >::F_slow

private

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::initialize_data().

fast_rhs

template<class T >

std::function<void(int, int, int, T&, const T&, T&, T&, T&, const amrex::Real, const amrex::Real, const amrex::Real, const amrex::Real)> MRISplitIntegrator< T >::fast_rhs

private

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::set_fast_rhs().

force_stage1_single_substep

template<class T >

int MRISplitIntegrator< T >::force_stage1_single_substep

private

Do we follow the recommendation to only perform a single substep in the first RK stage.

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::setForceFirstStageSingleSubstep().

ncomp_cons

template<class T >

int MRISplitIntegrator< T >::ncomp_cons

private

How many components in the cell-centered MultiFab.

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::setNcompCons().

no_substep

template<class T >

std::function<void (T&, T&, T&, amrex::Real, amrex::Real, int)> MRISplitIntegrator< T >::no_substep

private

The no_substep function is called when we have no acoustic substepping.

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::set_no_substep().

no_substepping

template<class T >

int MRISplitIntegrator< T >::no_substepping

private

Should we not do acoustic substepping.

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::setNoSubstepping().

rhs

template<class T >

std::function<void(T&, const T&, const amrex::Real, const amrex::Real )> MRISplitIntegrator< T >::rhs

private

rhs is the right-hand-side function the integrator will use.

Referenced by MRISplitIntegrator< T >::get_rhs().

S_scratch

template<class T >

T* MRISplitIntegrator< T >::S_scratch

private

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::initialize_data().

S_sum

template<class T >

T* MRISplitIntegrator< T >::S_sum

private

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::initialize_data().

slow_fast_timestep_ratio

template<class T >

int MRISplitIntegrator< T >::slow_fast_timestep_ratio = 0

private

The ratio of slow timestep size / fast timestep size (int)

Referenced by MRISplitIntegrator< T >::get_slow_fast_timestep_ratio(), and MRISplitIntegrator< T >::set_slow_fast_timestep_ratio().

slow_rhs_inc

template<class T >

std::function<void(T&, T&, T&, T&, const amrex::Real, const amrex::Real, const amrex::Real, const int)> MRISplitIntegrator< T >::slow_rhs_inc

private

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::set_slow_rhs_inc().

slow_rhs_post

template<class T >

std::function<void(T&, T&, T&, T&, T&, const amrex::Real, const amrex::Real, const amrex::Real, const int )> MRISplitIntegrator< T >::slow_rhs_post

private

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::set_slow_rhs_post().

slow_rhs_pre

template<class T >

std::function<void(T&, T&, T&, T&, const amrex::Real, const amrex::Real, const amrex::Real, const int)> MRISplitIntegrator< T >::slow_rhs_pre

private

Referenced by MRISplitIntegrator< T >::advance(), and MRISplitIntegrator< T >::set_slow_rhs_pre().

T_store

template<class T >

amrex::Vector<std::unique_ptr<T> > MRISplitIntegrator< T >::T_store

private

Referenced by MRISplitIntegrator< T >::initialize_data(), and MRISplitIntegrator< T >::map_data().

timestep

template<class T >

amrex::Real MRISplitIntegrator< T >::timestep

private

Integrator timestep size (Real)

Referenced by MRISplitIntegrator< T >::advance().

---

The documentation for this class was generated from the following file:

• Source/TimeIntegration/ERF_MRI.H