encap_sweeper.hpp

Go to the documentation of this file.

#ifndef _PFASST_ENCAP_ENCAP_SWEEPER_HPP_
#define _PFASST_ENCAP_ENCAP_SWEEPER_HPP_

#include <memory>
#include <vector>
using namespace std;

#include "pfasst/interfaces.hpp"
#include "pfasst/quadrature.hpp"
#include "pfasst/encap/encapsulation.hpp"


namespace pfasst
{
  namespace encap
  {
    using namespace pfasst::quadrature;


    template<typename time = time_precision>
    class EncapSweeper
      : public ISweeper<time>
    {
      protected:
        shared_ptr<IQuadrature<time>> quadrature;

        shared_ptr<EncapFactory<time>> factory;

        shared_ptr<Encapsulation<time>> start_state;

        shared_ptr<Encapsulation<time>> end_state;

        vector<shared_ptr<Encapsulation<time>>> residuals;


        vector<shared_ptr<Encapsulation<time>>> state;

        vector<shared_ptr<Encapsulation<time>>> saved_state;

        vector<shared_ptr<Encapsulation<time>>> fas_corrections;

        int residual_norm_order;

        time abs_residual_tol;

        time rel_residual_tol;

        string FORMAT_STR;

      public:
        EncapSweeper();


        virtual shared_ptr<Encapsulation<time>> get_state(size_t m) const;

        virtual shared_ptr<Encapsulation<time>> get_tau(size_t m) const;

        virtual shared_ptr<Encapsulation<time>> get_saved_state(size_t m) const;


        virtual void set_options() override;

        virtual void setup(bool coarse) override;


        virtual void spread() override;

        virtual void save(bool initial_only) override;

        virtual void set_quadrature(shared_ptr<IQuadrature<time>> quadrature);
        virtual shared_ptr<const IQuadrature<time>> get_quadrature() const;

        virtual const vector<time> get_nodes() const;

        virtual void set_factory(shared_ptr<EncapFactory<time>> factory);
        virtual shared_ptr<EncapFactory<time>> get_factory() const;

        virtual shared_ptr<Encapsulation<time>> get_start_state() const;
        virtual shared_ptr<Encapsulation<time>> get_end_state();


        virtual void advance() override;

        virtual void reevaluate(bool initial_only = false);

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


        void set_residual_tolerances(time abs_residual_tol, time rel_residual_tol, int order = 0);

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

        virtual bool converged() override;


        virtual void post(ICommunicator* comm, int tag) override;

        virtual void send(ICommunicator* comm, int tag, bool blocking) override;

        virtual void recv(ICommunicator* comm, int tag, bool blocking) override;

        virtual void broadcast(ICommunicator* comm) override;
    };


    template<typename time>
    EncapSweeper<time>& as_encap_sweeper(shared_ptr<ISweeper<time>> x);

    template<typename time>
    const EncapSweeper<time>& as_encap_sweeper(shared_ptr<const ISweeper<time>> x);
  }  // ::pfasst::encap
}  // ::pfasst

#include "pfasst/encap/encap_sweeper_impl.hpp"

#endif