wmimplicitrkscheme.h

Go to the documentation of this file.

#ifndef WMIMPLICITRKSCHEME_H
#define WMIMPLICITRKSCHEME_H
 
#include "warpxm/warpxm_config.h"
 
#include "array/array.h"
 
#include "hostactions/wmtemporalsolver.h"
 
#include <petscvec.h>
 
// STL includes
#include <vector>
 
class WmUnstructuredPatch;
 
namespace wxm
{
namespace variable
{
class distributed_variable_t;
}
 
namespace temporal
{
 
class implicit;
 
class ImplicitRKScheme
{
    std::vector<Vec> stages_;
 
    bool extra_accumulator_;
 
    std::vector<std::pair<size_t, size_t>> copy_ranges_;
 
    implicit* ts_ = nullptr;
 
    struct pimpl;
 
    pimpl* impl_;
 
public:
    // pair of variable/component
    typedef std::vector<std::pair<wxm::variable::distributed_variable_t*, size_t>>
        variables_type;
 
    ImplicitRKScheme(int num_stages,
                     std::vector<real> time_updates,
                     std::vector<real> multipliers,
                     bool extra_accumulator);
 
    ImplicitRKScheme(const ImplicitRKScheme&) = delete;
 
    ~ImplicitRKScheme();
 
    int getNumStages() const
    {
        return _numStages;
    }
    real getTimeUpdate(const int rkStage) const
    {
        return timeUpdates_[rkStage];
    }
    real getCFLLimit() const
    {
        return _cfl_max;
    }
 
    void allocate(MPI_Comm comm,
                  const std::vector<wxm::temporal_solver::temporal_var>& temporal_vars,
                  implicit& ts);
 
    WxStepperStatus
    calc_stage(int stage,
               const std::vector<wxm::temporal_solver::temporal_var>& temporal_vars,
               std::vector<variables_type>& vars,
               real dt);
 
    void print_stage_definition(int stage) const;
 
protected:
    int stage_offset(int stage) const
    {
        return ((stage + 1) * (stage + 2) >> 1) - 1;
    }
 
    real _cfl_max = 1;
    int _numStages;
    std::vector<real> timeUpdates_;
    std::vector<real> multipliers_;
};
} // namespace temporal
} // namespace wxm
 
#endif