Merge pull request #1 from torbjoernk/feature/parameterized-scalar-tests

tests: scalar: Yo Dawg, I herd you like better tests

Author: Daniel Ruprecht

include/pfasst/quadrature.hpp

@@ -160,8 +160,17 @@ namespace pfasst
         return p2;
       }
   };
-  
-  enum class QuadratureType { GaussLegendre, GaussLobatto, GaussRadau, ClenshawCurtis, Uniform };
+
+
+  enum class QuadratureType {
+      GaussLegendre
+    , GaussLobatto
+    , GaussRadau
+    , ClenshawCurtis
+    , Uniform
+  };
+
+
   template<typename node = time_precision>
   vector<node> compute_nodes(size_t nnodes, QuadratureType qtype)
   {

tests/examples/scalar/test_scalar.cpp

@@ -8,6 +8,8 @@
 
 using namespace ::testing;
 
+#include <pfasst/quadrature.hpp>
+
 #define PFASST_UNIT_TESTING
 #include "../examples/scalar/scalar_sdc.cpp"
 #undef PFASST_UNIT_TESTING
@@ -16,76 +18,81 @@ using namespace ::testing;
  * parameterized test fixture with number of nodes as parameter
  */
 class ConvergenceTest
-  : public ::testing::TestWithParam<size_t>
+  : public TestWithParam<tuple<size_t, pfasst::QuadratureType>>
 {
   protected:
     size_t nnodes; // parameter
 
-    complex<double> lambda = complex<double>(-1.0, 1.0);
-    double Tend = 4.0;
-    vector<size_t> nsteps = { 2, 5, 10, 15, 20 };
+    complex<double> lambda;
+    double Tend;
+    vector<size_t> nsteps;
     size_t nsteps_l;
     vector<double> err;
-    vector<double> convrate_lobatto;
-    vector<double> convrate_legendre;
+    vector<double> convrate;
     double dt;
     size_t niters;
-    pfasst::QuadratureType nodetype = pfasst::QuadratureType::GaussLobatto;
+    pfasst::QuadratureType nodetype;
+    size_t nnodes_in_call;
+
+    // set parameters base on node type
+    void set_parameters()
+    {
+      switch (this->nodetype)
+      {
+        case pfasst::QuadratureType::GaussLobatto:
+          this->niters = 2 * this->nnodes - 2;
+          this->Tend = 4.0;
+          this->lambda = complex<double>(-1.0, 1.0);
+          this->nsteps = { 2, 5, 10, 15, 20 };
+          this->nnodes_in_call = this->nnodes;
+          break;
+
+        case pfasst::QuadratureType::GaussLegendre:
+          this->niters = 2 * this->nnodes;
+          this->Tend = 6.0;
+          this->lambda = complex<double>(-1.0, 2.0);
+          this->nsteps = { 2, 4, 6, 8, 10 };
+          this->nnodes_in_call = this->nnodes + 2;
+          break;
+
+        /*
+        case pfasst::QuadratureType::GaussRadau:
+          break;
+
+        case pfasst::QuadratureType::ClenshawCurtis:
+          break;
+
+        case pfasst::QuadratureType::Uniform:
+          break;
+         */
+
+        default:
+          break;
+      }
+    }
 
   public:
     virtual void SetUp()
     {
-      this->nnodes = this->GetParam();
+      this->nnodes = get<0>(GetParam());
+      this->nodetype = get<1>(GetParam());
+      this->set_parameters();
       this->nsteps_l = this->nsteps.size();
       this->err.resize(this->nsteps.size());
-      this->convrate_lobatto.resize(this->nsteps.size());
-    
-      // Run first for Lobatto nodes which is the default nodetype
-
-      // Expect convergence rate of 2*nodes-2 from collocation formula,
-      // doing an identical number of iteration should suffice to reach this as each
-      // iteration should increase order by one
-      this->niters = 2 * nnodes - 2;
+      this->convrate.resize(this->nsteps.size());
 
       // run to compute errors
-      for (size_t i = 0; i <= nsteps_l - 1; ++i) {
-        dt = Tend / double(nsteps[i]);
-        err[i] = run_scalar_sdc(nsteps[i], dt, nnodes, niters, lambda, nodetype);
+      for (size_t i = 0; i <= this->nsteps_l - 1; ++i) {
+        this->dt = this->Tend / double(this->nsteps[i]);
+        this->err[i] = run_scalar_sdc(this->nsteps[i], this->dt, this->nnodes_in_call, 
+                                      this->niters, this->lambda, this->nodetype);
       }
 
       // compute convergence rates
-      for (size_t i = 0; i <= nsteps_l - 2; ++i) {
-        convrate_lobatto[i] = log10(err[i+1] / err[i]) / log10(double(nsteps[i]) / double(nsteps[i + 1]));
+      for (size_t i = 0; i <= this->nsteps_l - 2; ++i) {
+        this->convrate[i] = log10(this->err[i+1] / this->err[i]) / 
+                              log10(double(this->nsteps[i]) / double(this->nsteps[i + 1]));
       }
-       
-      /*    
-       * Compute convergence rates for Legendre nodes. 
-       * Note that this is not a particularly nice way to do the test, because both types 
-       * of nodes are tested in the same test. Having separate tests would be nicer...
-       */ 
-      nodetype = pfasst::QuadratureType::GaussLegendre;
-      this->convrate_legendre.resize(this->nsteps.size());
-      
-      // refine parameter
-      complex<double> lambda = complex<double>(-1.0, 2.0);      
-      this->Tend = 6.0;
-      this->nsteps = { 2, 4, 6, 8, 10 };
-      this->niters = 2*nnodes;
-      
-      // run to compute errors
-      for (size_t i = 0; i <= nsteps_l - 1; ++i) {
-        dt = Tend / double(nsteps[i]);
-        
-      // NOTE: Setting M for Legendre nodes actually only results in M-2 "real" nodes,
-      // because the first and the last are used for initial and final value.      
-      // Hence us nnodes+2 as argument  
-        err[i] = run_scalar_sdc(nsteps[i], dt, nnodes+2, niters, lambda, nodetype);
-      }
-      
-      for (size_t i = 0; i <= nsteps_l - 2; ++i) {
-        convrate_legendre[i] = log10(err[i+1] / err[i]) / log10(double(nsteps[i]) / double(nsteps[i + 1]));
-      }
-            
     }
 
     virtual void TearDown()
@@ -94,29 +101,62 @@ class ConvergenceTest
 
 /*
  * The test below verifies that the code approximately (up to a safety factor) reproduces
- * the theoretically expected rate of convergence for Lobatto and Legendre nodes
+ * the theoretically expected rate of convergence
  */
 TEST_P(ConvergenceTest, GaussNodes)
 {
   for (size_t i = 0; i <= nsteps_l - 2; ++i) {
+    switch (this->nodetype)
+    {
+      case pfasst::QuadratureType::GaussLobatto:
+        // Expect convergence rate of 2*nodes-2 from collocation formula, doing an identical number
+        // of iteration should suffice to reach this as each iteration should increase order by one
+        EXPECT_THAT(convrate[i],
+                    DoubleNear(double(2 * nnodes - 2), 0.99)) << "Convergence rate for " 
+                                                              << this->nnodes
+                                                              << " Gauss-Lobatto nodes "
+                                                              << " at node " << i 
+                                                              << " not within expected range.";
+        break;
+
+      case pfasst::QuadratureType::GaussLegendre:
+        // convergence rates for Legendre nodes should be 2*nodes but are actually better, so
+        // use Ge here
+        EXPECT_THAT(convrate[i], Ge<double>(2 * this->nnodes)) << "Convergence rate for " 
+                                                               << this->nnodes
+                                                               << " Gauss-Legendre nodes "
+                                                               << " at node " << i 
+                                                               << " not within expected range.";
+        break;
 
-    // Lobatto nodes reproduce the convergence rate quite accurately, so use DoubleNear
-    EXPECT_THAT(convrate_lobatto[i],
-                testing::DoubleNear(double(2 * nnodes - 2), 0.99)) << "Convergence rate at node "
-                                                                   << i
-                                                                   << " not within expected range";
-                                                                   
-    // convergence rates for Legendre nodes should be 2*nodes but are actually better, so
-    // use Ge here
-    EXPECT_THAT(convrate_legendre[i],
-                testing::Ge(double(2 * nnodes))) << "Convergence rate at node "
-                                                 << i
-                                                 << " not within expected range";                                                                
+      /*
+      case pfasst::QuadratureType::GaussRadau:
+        break;
 
+      case pfasst::QuadratureType::ClenshawCurtis:
+        break;
+
+      case pfasst::QuadratureType::Uniform:
+        break;
+       */
+
+      default:
+        EXPECT_TRUE(false);
+        break;
+    }
   }
 }
 
-INSTANTIATE_TEST_CASE_P(ScalarSDC, ConvergenceTest, Range<size_t>(2, 7));
+
+INSTANTIATE_TEST_CASE_P(ScalarSDC, ConvergenceTest,
+                        Combine(Range<size_t>(2, 7),
+                                Values(pfasst::QuadratureType::GaussLobatto,
+                                       pfasst::QuadratureType::GaussLegendre/*,
+                                       pfasst::QuadratureType::GaussRadau,
+                                       pfasst::QuadratureType::ClenshawCurtis,
+                                       pfasst::QuadratureType::Uniform*/))
+);
+
 
 int main(int argc, char** argv)
 {