interfaces.hpp

Go to the documentation of this file.

#ifndef _PFASST_INTERFACES_HPP_
#define _PFASST_INTERFACES_HPP_

#include <memory>
#include <stdexcept>
#include <string>
using namespace std;


namespace pfasst
{
  using time_precision = double;


  class NotImplementedYet
    : public runtime_error
  {
    public:
      explicit NotImplementedYet(const string& msg);
      virtual const char* what() const throw();
  };


  class ValueError
    : public invalid_argument
  {
    public:
      explicit ValueError(const string& msg);
      virtual const char* what() const throw();
  };


  // forward declare for IStatus
  class IStatus;


  class ICommunicator
  {
    public:
      virtual ~ICommunicator();
      virtual int size() = 0;
      virtual int rank() = 0;

      shared_ptr<IStatus> status;
  };


  class IStatus
  {
    public:
      static const int NOT_CONVERGED = 0;
      static const int CONVERGED = 1;

    protected:
      ICommunicator* comm;

    public:
      virtual ~IStatus();


      virtual void clear() = 0;

      virtual void set_converged(bool converged) = 0;

      virtual bool get_converged(int rank) = 0;


      virtual void set_comm(ICommunicator* comm);

      virtual bool previous_is_iterating();

      virtual bool keep_iterating();

      virtual void post(int tag) = 0;
      virtual void send(int tag) = 0;
      virtual void recv(int tag) = 0;
  };


  // forward declare for ISweeper
  template<typename time>
  class Controller;


  template<typename time = time_precision>
  class ISweeper
  {
    protected:
      Controller<time>* controller;

    public:
      ISweeper();
      virtual ~ISweeper();


      virtual void set_controller(Controller<time>* ctrl);

      virtual Controller<time>* get_controller();


      virtual void set_options();

      virtual void setup(bool coarse = false);

      virtual void predict(bool initial) = 0;

      virtual void sweep() = 0;

      virtual void advance() = 0;

      virtual bool converged();

      virtual void save(bool initial_only=false);

      virtual void spread();


      virtual void post_sweep();

      virtual void post_predict();

      virtual void post_step();

      virtual void post(ICommunicator* comm, int tag);
      virtual void send(ICommunicator* comm, int tag, bool blocking);
      virtual void recv(ICommunicator* comm, int tag, bool blocking);
      virtual void broadcast(ICommunicator* comm);
  };


  template<typename time = time_precision>
  class ITransfer
  {
    public:
      virtual ~ITransfer();


      virtual void interpolate_initial(shared_ptr<ISweeper<time>> dst,
                                       shared_ptr<const ISweeper<time>> src);

      virtual void interpolate(shared_ptr<ISweeper<time>> dst,
                               shared_ptr<const ISweeper<time>> src,
                               bool interp_initial = false) = 0;


      virtual void restrict_initial(shared_ptr<ISweeper<time>> dst,
                                    shared_ptr<const ISweeper<time>> src);


      virtual void restrict(shared_ptr<ISweeper<time>> dst,
                            shared_ptr<const ISweeper<time>> src,
                            bool restrict_initial = false) = 0;


      virtual void fas(time dt, shared_ptr<ISweeper<time>> dst,
                       shared_ptr<const ISweeper<time>> src) = 0;
  };
}  // ::pfasst

#include "pfasst/interfaces_impl.hpp"

#endif