Merge pull request #118 from memmett/feature/movestate-merge

Use `shared_ptr` for quadrature, move `state` etc to `encap_sweeper` (2nd try).

Author: torbjoernk

include/pfasst/encap/encap_sweeper.hpp

@@ -19,53 +19,137 @@ namespace pfasst
 {
   namespace encap
   {
+    using namespace pfasst::quadrature;
+
     template<typename time = time_precision>
     class EncapSweeper
       : public ISweeper<time>
     {
       protected:
         //! @{
-        quadrature::IQuadrature<time>* quad;
+        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;
         //! @}
 
+        //! @{
+        /**
+         * Solution values \\( U \\) at all time nodes of the current iteration.
+         */
+        vector<shared_ptr<Encapsulation<time>>> state;
+
+        /**
+         * Solution values \\( U \\) at all time nodes of the previous iteration.
+         */
+        vector<shared_ptr<Encapsulation<time>>> saved_state;
+
+        /**
+         * FAS corrections \\( \\tau \\) at all time nodes of the current iteration.
+         */
+        vector<shared_ptr<Encapsulation<time>>> fas_corrections;
+        //! @}
+
         int residual_norm_order;
         time abs_residual_tol, rel_residual_tol;
 
       public:
-        //! @{
+
         EncapSweeper()
-          : quad(nullptr), abs_residual_tol(0.0), rel_residual_tol(0.0)
+          : quadrature(nullptr), abs_residual_tol(0.0), rel_residual_tol(0.0)
         {}
 
-        virtual ~EncapSweeper()
+        //! @{
+        /**
+         * Retrieve solution values of current iteration at time node index `m`.
+         *
+         * @param[in] m 0-based index of time node
+         */
+        virtual shared_ptr<Encapsulation<time>> get_state(size_t m) const
         {
-          if (this->quad) delete this->quad;
+          return this->state[m];
+        }
+
+        /**
+         * Retrieve FAS correction of current iteration at time node index `m`.
+         *
+         * @param[in] m 0-based index of time node
+         */
+        virtual shared_ptr<Encapsulation<time>> get_tau(size_t m) const
+        {
+          return this->fas_corrections[m];
+        }
+
+        /**
+         * Retrieve solution values of previous iteration at time node index `m`.
+         *
+         * @param[in] m 0-based index of time node
+         */
+        virtual shared_ptr<Encapsulation<time>> get_saved_state(size_t m) const
+        {
+          return this->saved_state[m];
         }
         //! @}
 
+        virtual void setup(bool coarse) override
+        {
+          auto const nodes = this->quadrature->get_nodes();
+          auto const num_nodes = this->quadrature->get_num_nodes();
+
+          this->start_state = this->get_factory()->create(pfasst::encap::solution);
+          this->end_state = this->get_factory()->create(pfasst::encap::solution);
+
+          for (size_t m = 0; m < num_nodes; m++) {
+            this->state.push_back(this->get_factory()->create(pfasst::encap::solution));
+            if (coarse) {
+              this->saved_state.push_back(this->get_factory()->create(pfasst::encap::solution));
+            }
+          }
+
+          if (coarse) {
+            size_t num_fas = this->quadrature->left_is_node() ? num_nodes -1 : num_nodes;
+            for (size_t m = 0; m < num_fas; m++) {
+              this->fas_corrections.push_back(this->get_factory()->create(pfasst::encap::solution));
+            }
+          }
+
+        }
+
         //! @{
         virtual void spread() override
         {
-          for (size_t m = 1; m < this->quad->get_num_nodes(); m++) {
+          for (size_t m = 1; m < this->quadrature->get_num_nodes(); m++) {
             //            this->get_state(m)->copy(this->start_state);
-            this->get_state(m)->copy(this->get_state(0));
+            this->state[m]->copy(this->state[0]);
           }
         }
         //! @}
 
+        /**
+         * Save current solution states.
+         */
+        virtual void save(bool initial_only) override
+        {
+          // XXX: if !left_is_node, this is a problem...
+          if (initial_only) {
+            this->saved_state[0]->copy(state[0]);
+          } else {
+            for (size_t m = 0; m < this->saved_state.size(); m++) {
+              this->saved_state[m]->copy(state[m]);
+            }
+          }
+        }
+
         //! @{
-        void set_quadrature(quadrature::IQuadrature<time>* quad)
+        void set_quadrature(shared_ptr<IQuadrature<time>> quadrature)
         {
-          this->quad = quad;
+          this->quadrature = quadrature;
         }
 
-        const quadrature::IQuadrature<time>* get_quadrature() const
+        shared_ptr<const IQuadrature<time>> get_quadrature() const
         {
-          return this->quad;
+          return this->quadrature;
         }
 
         shared_ptr<Encapsulation<time>> get_start_state() const
@@ -75,7 +159,7 @@ namespace pfasst
 
         const vector<time> get_nodes() const
         {
-          return this->quad->get_nodes();
+          return this->quadrature->get_nodes();
         }
 
         void set_factory(shared_ptr<EncapFactory<time>> factory)
@@ -88,48 +172,6 @@ namespace pfasst
           return factory;
         }
 
-        /**
-         * retrieve solution values of current iteration at time node index `m`
-         *
-         * @param[in] m 0-based index of time node
-         *
-         * @note This method must be implemented in derived sweepers.
-         */
-        virtual shared_ptr<Encapsulation<time>> get_state(size_t m) const
-        {
-          UNUSED(m);
-          throw NotImplementedYet("sweeper");
-          return NULL;
-        }
-
-        /**
-         * retrieves FAS correction of current iteration at time node index `m`
-         *
-         * @param[in] m 0-based index of time node
-         *
-         * @note This method must be implemented in derived sweepers.
-         */
-        virtual shared_ptr<Encapsulation<time>> get_tau(size_t m) const
-        {
-          UNUSED(m);
-          throw NotImplementedYet("sweeper");
-          return NULL;
-        }
-
-        /**
-         * retrieves solution values of previous iteration at time node index `m`
-         *
-         * @param[in] m 0-based index of time node
-         *
-         * @note This method must be implemented in derived sweepers.
-         */
-        virtual shared_ptr<Encapsulation<time>> get_saved_state(size_t m) const
-        {
-          UNUSED(m);
-          throw NotImplementedYet("sweeper");
-          return NULL;
-        }
-
         virtual shared_ptr<Encapsulation<time>> get_end_state()
         {
           return this->end_state;
@@ -229,25 +271,29 @@ namespace pfasst
         //! @{
         virtual void post(ICommunicator* comm, int tag) override
         {
-          this->get_state(0)->post(comm, tag);
+          this->start_state->post(comm, tag);
         }
 
         virtual void send(ICommunicator* comm, int tag, bool blocking) override
         {
-          this->get_state(this->get_nodes().size() - 1)->send(comm, tag, blocking);
+          this->end_state->send(comm, tag, blocking);
         }
 
         virtual void recv(ICommunicator* comm, int tag, bool blocking) override
         {
-          this->get_state(0)->recv(comm, tag, blocking);
+          this->start_state->recv(comm, tag, blocking);
+          // XXX
+          this->state.front()->copy(this->start_state);
         }
 
         virtual void broadcast(ICommunicator* comm) override
         {
           if (comm->rank() == comm->size() - 1) {
-            this->get_state(0)->copy(this->get_state(this->get_nodes().size() - 1));
+            this->start_state->copy(this->end_state);
           }
-          this->get_state(0)->broadcast(comm);
+          this->start_state->broadcast(comm);
+          // XXX
+          this->state.front()->copy(this->start_state);
         }
         //! @}
     };