auto: Add auto_build, auto_initial, and ex3.cpp.

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

Author: memmett

examples/advection_diffusion/ex2.cpp

@@ -10,9 +10,12 @@
 #include "advection_diffusion_sweeper.hpp"
 #include "spectral_transfer_1d.hpp"
 
+using namespace pfasst;
+using namespace pfasst::encap;
+
 int main(int argc, char **argv)
 {
-  pfasst::MLSDC<double> mlsdc;
+  MLSDC<double> mlsdc;
 
   const int    nlevs  = 2;
   const int    nsteps = 4;
@@ -31,8 +34,8 @@ int main(int argc, char **argv)
    * (according to 'xrat').
    */
   for (int l=0; l<nlevs; l++) {
-    auto  nodes    = pfasst::compute_nodes<double>(nnodes, "gauss-lobatto");
-    auto* factory  = new pfasst::encap::VectorFactory<double,double>(ndofs);
+    auto  nodes    = compute_nodes<double>(nnodes, "gauss-lobatto");
+    auto* factory  = new VectorFactory<double,double>(ndofs);
     auto* sweeper  = new AdvectionDiffusionSweeper<double,double>(ndofs);
     auto* transfer = new SpectralTransfer1D<double,double>();
 

examples/advection_diffusion/ex3.cpp

@@ -0,0 +1,67 @@
+/*
+ * Advection/diffusion example using an encapsulated IMEX sweeper.
+ *
+ * This example uses a (serial) multi-level SDC sweeper.  It is
+ * functionally exactly the same as ex2.cpp, but uses the 'auto
+ * builder' to shorten the build and setup stages of the MLSDC
+ * controller.
+ */
+
+#include <tuple>
+
+#include <pfasst.hpp>
+#include <pfasst/encap/automagic.hpp>
+#include <pfasst/encap/vector.hpp>
+
+#include "advection_diffusion_sweeper.hpp"
+#include "spectral_transfer_1d.hpp"
+
+using namespace std;
+using namespace pfasst;
+using namespace pfasst::encap;
+
+int main(int argc, char **argv)
+{
+  MLSDC<double> mlsdc;
+
+  const int    nsteps = 4;
+  const double dt     = 0.01;
+  const int    niters = 4;
+
+  vector<pair<int,string>> nodes = {
+    { 3, "gauss-lobatto" },
+    { 5, "gauss-lobatto" }
+  };
+
+  vector<int> ndofs = { 64, 128 };
+
+  /*
+   * the 'build' function is called once for each level, and returns a
+   * tuple containing a sweeper, encapsulation factory, and transfer
+   * routines.  in this case our builder is a lambda function that
+   * captures the 'ndofs' variable from above.
+   */
+  auto build_level = [ndofs] (unsigned int level) {
+    auto* factory  = new VectorFactory<double,double>(ndofs[level]);
+    auto* sweeper  = new AdvectionDiffusionSweeper<double,double>(ndofs[level]);
+    auto* transfer = new SpectralTransfer1D<double,double>();
+
+    return auto_build_tuple<double,double>(sweeper,transfer,factory);
+  };
+
+  /*
+   * the 'initial' function is called once for each level to set the
+   * intial conditions.
+   */
+  auto initial = [] (EncapsulatedSweeperMixin<double,double> *sweeper, Encapsulation<double,double> *q0) {
+    auto* ad = dynamic_cast<AdvectionDiffusionSweeper<double,double>*>(sweeper);
+    ad->exact(q0, 0.0);
+  };
+
+  auto_build<double,double>(mlsdc, nodes, build_level);
+  auto_setup<double,double>(mlsdc, initial);
+  mlsdc.set_duration(dt, nsteps, niters);
+  mlsdc.run();
+
+  return 0;
+}

examples/advection_diffusion/fft.hpp

@@ -31,7 +31,16 @@ class FFT {
 
   ~FFT()
   {
-    // XXX
+    for (auto& x: workspaces) {
+      auto* wk = std::get<1>(x);
+      fftw_destroy_plan(wk->ffft);
+      fftw_destroy_plan(wk->ifft);
+      fftw_free(wk->wk);
+      delete wk;
+      //      workspaces.erase(std::get<0>(x));
+    }
+    workspaces.clear();
+    // workspaces.clear();
   }
 
   workspace* get_workspace(int ndofs)

include/pfasst/encap/automagic.hpp

@@ -0,0 +1,50 @@
+
+#ifndef _PFASST_ENCAP_AUTOMAGIC_HPP_
+#define _PFASST_ENCAP_AUTOMAGIC_HPP_
+
+#include <tuple>
+
+#include "../quadrature.hpp"
+#include "encapsulation.hpp"
+
+using namespace std;
+
+namespace pfasst {
+  namespace encap {
+
+    template<typename scalar, typename time>
+    using auto_build_tuple = tuple<pfasst::encap::EncapsulatedSweeperMixin<scalar,time>*,
+				   pfasst::ITransfer*,
+				   pfasst::encap::EncapsulationFactory<scalar,time>*>;
+
+    template<typename scalar, typename time, typename controllerT, typename buildT>
+    void auto_build(controllerT& c, vector<pair<int,string>> nodes, buildT build) {
+      for (unsigned int l=0; l<nodes.size(); l++) {
+	auto nds = pfasst::compute_nodes<time>(get<0>(nodes[l]), get<1>(nodes[l]));
+	auto_build_tuple<scalar,time> tpl = build(l);
+	auto* sweeper = get<0>(tpl);
+	auto* transfer = get<1>(tpl);
+	auto* factory = get<2>(tpl);
+	sweeper->set_nodes(nds);
+	sweeper->set_factory(factory);
+	c.add_level(sweeper, transfer, false);
+      }
+    }
+
+    template<typename scalar, typename time, typename controllerT, typename initialT>
+    void auto_setup(controllerT& c, initialT initial) {
+      c.setup();
+      for (int l=0; l<c.nlevels(); l++) {
+	//	auto* sweeper = c.get_level<pfasst::encap::EncapsulatedSweeperMixin<scalar,time>>(l);
+	auto* isweeper = c.get_level(l);
+	auto* sweeper = dynamic_cast<pfasst::encap::EncapsulatedSweeperMixin<scalar,time>*>(isweeper);
+	auto* q0 = sweeper->get_state(0);
+	initial(sweeper, q0);
+	// sweeper->exact(q0, 0.0);
+      }
+    }
+
+  }
+}
+
+#endif

include/pfasst/encap/imex.hpp

@@ -22,9 +22,10 @@ namespace pfasst {
 
       ~IMEX()
       {
-	for (int m=0; m<Q.size(); m++) delete Q[m];
+	for (int m=0; m<Q.size(); m++)  delete Q[m];
+	for (int m=0; m<S.size(); m++)  delete S[m];
+	for (int m=0; m<T.size(); m++)  delete T[m];
 	for (int m=0; m<pQ.size(); m++) delete pQ[m];
-	for (int m=0; m<S.size(); m++) delete S[m];
 	for (int m=0; m<Fe.size(); m++) delete Fe[m];
 	for (int m=0; m<Fi.size(); m++) delete Fi[m];
       }