implicit_sweeper.hpp

Go to the documentation of this file.

#ifndef _PFASST_ENCAP_IMPLICIT_SWEEPER_HPP_
#define _PFASST_ENCAP_IMPLICIT_SWEEPER_HPP_

#include <memory>
#include <vector>

#include "pfasst/encap/encapsulation.hpp"
#include "pfasst/encap/encap_sweeper.hpp"

using namespace std;

namespace pfasst
{
  namespace encap
  {
    using pfasst::encap::Encapsulation;

    template<typename time = time_precision>
    class ImplicitSweeper
      : public pfasst::encap::EncapSweeper<time>
    {
      protected:

        vector<shared_ptr<Encapsulation<time>>> s_integrals;

        vector<shared_ptr<Encapsulation<time>>> fs_impl;

        Matrix<time> q_tilde;

        void set_end_state();

      public:
        ImplicitSweeper() = default;
        virtual ~ImplicitSweeper() = default;


        virtual void setup(bool coarse) override;

        virtual void predict(bool initial) override;

        virtual void sweep() override;

        virtual void advance() override;

        virtual void reevaluate(bool initial_only) override;

        virtual void integrate(time dt, vector<shared_ptr<Encapsulation<time>>> dst) const override;


        virtual void f_impl_eval(shared_ptr<Encapsulation<time>> f_impl_encap,
                                 shared_ptr<Encapsulation<time>> u_encap,
                                 time t)
        {
          UNUSED(f_impl_encap); UNUSED(u_encap); UNUSED(t);
          throw NotImplementedYet("implicit (f_impl_eval)");
        }

        virtual void impl_solve(shared_ptr<Encapsulation<time>> f_encap,
                                shared_ptr<Encapsulation<time>> u_encap,
                                time t, time dt,
                                shared_ptr<Encapsulation<time>> rhs_encap)
        {
          UNUSED(f_encap); UNUSED(u_encap); UNUSED(t); UNUSED(dt); UNUSED(rhs_encap);
          throw NotImplementedYet("implicit (impl_solve)");
        }
    };

  }  // ::pfasst::encap
}  // ::pfasst

#include "pfasst/encap/implicit_sweeper_impl.hpp"

#endif