encap: Put various classes into their own include files.

Signed-off-by: Matthew Emmett <[email protected]>

Author: memmett

examples/advection_diffusion/advection_diffusion_sweeper.hpp

@@ -8,7 +8,7 @@
 #include <complex>
 #include <vector>
 
-#include <pfasst/encap/imex.hpp>
+#include <pfasst/encap/imex_sweeper.hpp>
 #include "fft.hpp"
 
 #define pi     3.1415926535897932385
@@ -20,7 +20,7 @@ using pfasst::encap::Encapsulation;
 
 
 template<typename scalar, typename time>
-class AdvectionDiffusionSweeper : public pfasst::imex::IMEX<scalar,time> {
+class AdvectionDiffusionSweeper : public pfasst::encap::IMEXSweeper<scalar,time> {
 
   using dvector = pfasst::encap::VectorEncapsulation<scalar,time>;
   FFT<scalar,time> fft;
@@ -89,13 +89,13 @@ class AdvectionDiffusionSweeper : public pfasst::imex::IMEX<scalar,time> {
 
   void predict(time t, time dt, bool initial)
   {
-    pfasst::imex::IMEX<scalar,time>::predict(t, dt, initial);
+    pfasst::encap::IMEXSweeper<scalar,time>::predict(t, dt, initial);
     echo_error(t+dt, true);
   }
 
   void sweep(time t, time dt)
   {
-    pfasst::imex::IMEX<scalar,time>::sweep(t, dt);
+    pfasst::encap::IMEXSweeper<scalar,time>::sweep(t, dt);
     echo_error(t+dt);
   }
 

examples/advection_diffusion/ex3.cpp

@@ -10,6 +10,7 @@
 #include <tuple>
 
 #include <pfasst.hpp>
+#include <pfasst/mlsdc.hpp>
 #include <pfasst/encap/automagic.hpp>
 #include <pfasst/encap/vector.hpp>
 

examples/advection_diffusion/spectral_transfer_1d.hpp

@@ -6,6 +6,8 @@
 #define _SPECTRAL_TRANSFER_1D_HPP_
 
 #include <pfasst/encap/vector.hpp>
+#include <pfasst/encap/poly_interp.hpp>
+
 #include "fft.hpp"
 
 template<typename scalar, typename time>

include/pfasst/encap/automagic.hpp

@@ -5,7 +5,7 @@
 #include <tuple>
 
 #include "../quadrature.hpp"
-#include "encapsulation.hpp"
+#include "encap_sweeper.hpp"
 
 using namespace std;
 

include/pfasst/encap/encap_sweeper.hpp

@@ -0,0 +1,92 @@
+/*
+ * Host based encapsulated base sweeper.
+ */
+
+#ifndef _PFASST_ENCAP_ENCAP_SWEEPER_HPP_
+#define _PFASST_ENCAP_ENCAP_SWEEPER_HPP_
+
+#include <vector>
+
+#include "../interfaces.hpp"
+#include "../quadrature.hpp"
+#include "encapsulation.hpp"
+
+namespace pfasst {
+  namespace encap {
+
+    template<typename scalar, typename time>
+    class EncapSweeper : public ISweeper {
+      vector<scalar> nodes;
+      shared_ptr<EncapFactory<scalar,time>> factory;
+
+    public:
+
+      void set_nodes(vector<time> nodes)
+      {
+	this->nodes = nodes;
+      }
+
+      const vector<time> get_nodes() const
+      {
+	return nodes;
+      }
+
+      void set_factory(EncapFactory<scalar,time>* factory)
+      {
+	this->factory = shared_ptr<EncapFactory<scalar,time>>(factory);
+      }
+
+      EncapFactory<scalar,time>* get_factory() const
+      {
+	return factory.get();
+      }
+
+      virtual void set_state(const Encapsulation<scalar,time>* q0, unsigned int m)
+      {
+      	throw NotImplementedYet("sweeper");
+      }
+
+      virtual Encapsulation<scalar,time>* get_state(unsigned int m) const
+      {
+	throw NotImplementedYet("sweeper");
+	return NULL;
+      }
+
+      virtual Encapsulation<scalar,time>* get_tau(unsigned int m) const
+      {
+	throw NotImplementedYet("sweeper");
+	return NULL;
+      }
+
+      virtual Encapsulation<scalar,time>* get_saved_state(unsigned int m) const
+      {
+	throw NotImplementedYet("sweeper");
+	return NULL;
+      }
+
+      virtual Encapsulation<scalar,time>* get_end_state()
+      {
+	return this->get_state(this->get_nodes().size()-1);
+      }
+
+      virtual void evaluate(int m)
+      {
+	throw NotImplementedYet("sweeper");
+      }
+
+      virtual void advance()
+      {
+	throw NotImplementedYet("sweeper");
+      }
+
+      virtual void integrate(time dt, vector<Encapsulation<scalar,time>*> dst) const
+      {
+	throw NotImplementedYet("sweeper");
+      }
+    };
+
+  }
+
+}
+
+#endif

include/pfasst/encap/encapsulation.hpp

@@ -55,216 +55,6 @@ namespace pfasst {
       virtual Encapsulation<scalar,time>* create(const EncapType) = 0;
     };
 
-    template<typename scalar, typename time>
-    class EncapSweeper : public ISweeper {
-      vector<scalar> nodes;
-      shared_ptr<EncapFactory<scalar,time>> factory;
-
-    public:
-
-      void set_nodes(vector<time> nodes)
-      {
-	this->nodes = nodes;
-      }
-
-      const vector<time> get_nodes() const
-      {
-	return nodes;
-      }
-
-      void set_factory(EncapFactory<scalar,time>* factory)
-      {
-	this->factory = shared_ptr<EncapFactory<scalar,time>>(factory);
-      }
-
-      EncapFactory<scalar,time>* get_factory() const
-      {
-	return factory.get();
-      }
-
-      virtual void set_state(const Encapsulation<scalar,time>* q0, unsigned int m)
-      {
-      	throw NotImplementedYet("sweeper");
-      }
-
-      virtual Encapsulation<scalar,time>* get_state(unsigned int m) const
-      {
-	throw NotImplementedYet("sweeper");
-	return NULL;
-      }
-
-      virtual Encapsulation<scalar,time>* get_tau(unsigned int m) const
-      {
-	throw NotImplementedYet("sweeper");
-	return NULL;
-      }
-
-      virtual Encapsulation<scalar,time>* get_saved_state(unsigned int m) const
-      {
-	throw NotImplementedYet("sweeper");
-	return NULL;
-      }
-
-      virtual Encapsulation<scalar,time>* get_end_state()
-      {
-	return this->get_state(this->get_nodes().size()-1);
-      }
-
-      virtual void evaluate(int m)
-      {
-	throw NotImplementedYet("sweeper");
-      }
-
-      virtual void advance()
-      {
-	throw NotImplementedYet("sweeper");
-      }
-
-      virtual void integrate(time dt, vector<Encapsulation<scalar,time>*> dst) const
-      {
-	throw NotImplementedYet("sweeper");
-      }
-    };
-
-    template<typename scalar, typename time>
-    class PolyInterpMixin : public pfasst::ITransfer {
-      matrix<time> tmat, fmat;
-
-    public:
-
-      virtual ~PolyInterpMixin() { }
-
-      virtual void interpolate(ISweeper *dst, const ISweeper *src,
-			       bool interp_delta_from_initial,
-			       bool interp_initial)
-      {
-	auto* fine = dynamic_cast<EncapSweeper<scalar,time>*>(dst);
-	auto* crse = dynamic_cast<const EncapSweeper<scalar,time>*>(src);
-
-	if (tmat.size1() == 0)
-	  tmat = pfasst::compute_interp<time>(fine->get_nodes(), crse->get_nodes());
-
-	int nfine = fine->get_nodes().size();
-	int ncrse = crse->get_nodes().size();
-
-	auto* crse_factory = crse->get_factory();
-	auto* fine_factory = fine->get_factory();
-
-	vector<Encapsulation<scalar,time>*> fine_state(nfine), fine_delta(ncrse);
-
-	for (int m=0; m<nfine; m++) fine_state[m] = fine->get_state(m);
-	for (int m=0; m<ncrse; m++) fine_delta[m] = fine_factory->create(solution);
-
-	if (interp_delta_from_initial)
-	  for (int m=1; m<nfine; m++)
-	    fine_state[m]->copy(fine_state[0]);
-
-	auto* crse_delta = crse_factory->create(solution);
-	int m0 = interp_initial ? 0 : 1;
-	for (int m=m0; m<ncrse; m++) {
-	  crse_delta->copy(crse->get_state(m));
-	  if (interp_delta_from_initial)
-	    crse_delta->saxpy(-1.0, crse->get_state(0));
-	  else
-	    crse_delta->saxpy(-1.0, crse->get_saved_state(m));
-	  interpolate(fine_delta[m], crse_delta);
-	}
-	delete crse_delta;
-
-	if (! interp_initial)
-	  fine_delta[0]->setval(0.0);
-
-	fine->get_state(0)->mat_apply(fine_state, 1.0, tmat, fine_delta, false);
-
-	for (int m=0; m<ncrse; m++) delete fine_delta[m];
-	for (int m=m0; m<nfine; m++) fine->evaluate(m);
-      }
-
-      virtual void restrict(ISweeper *dst, const ISweeper *src, bool restrict_initial)
-      {
-	auto* crse = dynamic_cast<EncapSweeper<scalar,time>*>(dst);
-	auto* fine = dynamic_cast<const EncapSweeper<scalar,time>*>(src);
-
-	auto dnodes = crse->get_nodes();
-	auto snodes = fine->get_nodes();
-
-	int ncrse = crse->get_nodes().size();
-	int nfine = fine->get_nodes().size();
-
-	int trat = (nfine - 1) / (ncrse - 1);
-
-	int m0 = restrict_initial ? 0 : 1;
-	for (int m=m0; m<ncrse; m++) {
-	  if (dnodes[m] != snodes[m*trat])
-	    throw NotImplementedYet("coarse nodes must be nested");
-	  this->restrict(crse->get_state(m), fine->get_state(m*trat));
-	}
-
-	for (int m=m0; m<ncrse; m++) crse->evaluate(m);
-      }
-
-      virtual void fas(time dt, ISweeper *dst, const ISweeper *src)
-      {
-	auto* crse = dynamic_cast<EncapSweeper<scalar,time>*>(dst);
-	auto* fine = dynamic_cast<const EncapSweeper<scalar,time>*>(src);
-
-	int ncrse = crse->get_nodes().size();
-	int nfine = fine->get_nodes().size();
-
-	auto* crse_factory = crse->get_factory();
-	auto* fine_factory = fine->get_factory();
-
-	vector<Encapsulation<scalar,time>*> crse_z2n(ncrse-1), fine_z2n(nfine-1), rstr_z2n(ncrse-1);
-	for (int m=0; m<ncrse-1; m++) crse_z2n[m] = crse_factory->create(solution);
-	for (int m=0; m<ncrse-1; m++) rstr_z2n[m] = crse_factory->create(solution);
-	for (int m=0; m<nfine-1; m++) fine_z2n[m] = fine_factory->create(solution);
-
-	// compute '0 to node' integral on the coarse level
-	crse->integrate(dt, crse_z2n);
-	for (int m=1; m<ncrse-1; m++)
-	  crse_z2n[m]->saxpy(1.0, crse_z2n[m-1]);
-
-	// compute '0 to node' integral on the fine level
-	fine->integrate(dt, fine_z2n);
-	for (int m=1; m<nfine-1; m++)
-	  fine_z2n[m]->saxpy(1.0, fine_z2n[m-1]);
-
-	// restrict '0 to node' fine integral
-	int trat = (nfine - 1) / (ncrse - 1);
-	for (int m=1; m<ncrse; m++)
-	  this->restrict(rstr_z2n[m-1], fine_z2n[m*trat-1]);
-
-	// compute 'node to node' tau correction
-	vector<Encapsulation<scalar,time>*> tau(ncrse-1);
-	for (int m=0; m<ncrse-1; m++) tau[m] = crse->get_tau(m);
-
-	tau[0]->copy(rstr_z2n[0]);
-	tau[0]->saxpy(-1.0, crse_z2n[0]);
-
-	for (int m=1; m<ncrse-1; m++) {
-	  tau[m]->copy(rstr_z2n[m]);
-	  tau[m]->saxpy(-1.0, rstr_z2n[m-1]);
-
-	  tau[m]->saxpy(-1.0, crse_z2n[m]);
-	  tau[m]->saxpy(1.0, crse_z2n[m-1]);
-	}
-
-	for (int m=0; m<ncrse-1; m++) delete crse_z2n[m];
-	for (int m=0; m<ncrse-1; m++) delete rstr_z2n[m];
-	for (int m=0; m<nfine-1; m++) delete fine_z2n[m];
-      }
-
-      // required for interp/restrict helpers
-      virtual void interpolate(Encapsulation<scalar,time> *dst, const Encapsulation<scalar,time> *src) {
-	throw NotImplementedYet("mlsdc/pfasst");
-      }
-
-      virtual void restrict(Encapsulation<scalar,time> *dst, const Encapsulation<scalar,time> *src) {
-	throw NotImplementedYet("mlsdc/pfasst");
-      }
-
-    };
-
   }
 }