scalar: some further cleanup

Author: torbjoernk

examples/scalar/scalar_sdc.cpp

@@ -18,28 +18,27 @@
  */
 
 double run_scalar_sdc(const size_t nsteps, const double dt, const size_t nnodes,
-  const size_t niters, const complex<double> lambda)
+                      const size_t niters, const complex<double> lambda)
 {
-
   pfasst::SDC<> sdc;
 
-  const complex<double> y0     = complex<double>(1.0, 0.0);
+  const complex<double> y0 = complex<double>(1.0, 0.0);
   auto nodes = pfasst::compute_nodes(nnodes, "gauss-lobatto");
   auto factory = make_shared<pfasst::encap::VectorFactory<complex<double>>>(1);
-  auto sweeper = make_shared<ScalarSweeper<>>(lambda,y0);
-  
+  auto sweeper = make_shared<ScalarSweeper<>>(lambda, y0);
+
   sweeper->set_nodes(nodes);
   sweeper->set_factory(factory);
-  
+
   sdc.add_level(sweeper);
   sdc.set_duration(0.0, dt*nsteps, dt, niters);
   sdc.setup();
-  
+
   auto q0 = sweeper->get_state(0);
   sweeper->exact(q0, 0.0);
-  
+
   sdc.run();
-  
+
   return sweeper->get_errors();
 }
 
@@ -51,7 +50,7 @@ int main(int /*argc*/, char** /*argv*/)
   const size_t nnodes = 4;
   const size_t niters = 6;
   const complex<double> lambda = complex<double>(-1.0, 1.0);
-  
+
   run_scalar_sdc(nsteps, dt, nnodes, niters, lambda);
 }
 #endif

examples/scalar/scalar_sweeper.hpp

@@ -21,27 +21,27 @@ class ScalarSweeper
     typedef pfasst::encap::Encapsulation<time> encap_type;
     typedef pfasst::encap::VectorEncapsulation<complex<double>> complex_vector_type;
 
-    complex<double> _lambda, _u0;
-    int _n_f_expl_eval, _n_f_impl_eval, _n_impl_solve;
+    complex<double> lambda, u0;
+    size_t n_f_expl_eval, n_f_impl_eval, n_impl_solve;
     const complex<double> i_complex = complex<double>(0, 1);
-    double _error;
+    double error;
 
   public:
     ScalarSweeper(complex<double> lambda, complex<double> u0)
-      :   _lambda(lambda)
-        , _u0(u0)
-        , _n_f_expl_eval(0)
-        , _n_f_impl_eval(0)
-        , _n_impl_solve(0)
-        , _error(0.0)
+      :   lambda(lambda)
+        , u0(u0)
+        , n_f_expl_eval(0)
+        , n_f_impl_eval(0)
+        , n_impl_solve(0)
+        , error(0.0)
     {}
 
     virtual ~ScalarSweeper()
     {
-      cout << "Final error:               " << scientific << this->_error << endl;
-      cout << "Number of explicit evaluations: " << this->_n_f_expl_eval << endl;
-      cout << "Number of implicit evaluations: " << this->_n_f_impl_eval << endl;
-      cout << "Number of implicit solves: " << this->_n_impl_solve << endl;
+      cout << "Final error:                    " << scientific << this->error << endl;
+      cout << "Number of explicit evaluations: " << this->n_f_expl_eval << endl;
+      cout << "Number of implicit evaluations: " << this->n_f_impl_eval << endl;
+      cout << "Number of implicit solves:      " << this->n_impl_solve << endl;
     }
 
     void echo_error(time t)
@@ -53,12 +53,12 @@ class ScalarSweeper
       this->exact(qex, t);
       double max_err = abs(qend[0] - qex[0]) / abs(qex[0]);
       cout << "err: " << scientific << max_err << endl;
-      this->_error = max_err;
+      this->error = max_err;
     }
-    
+
     double get_errors()
     {
-      return this->_error;    
+      return this->error;
     }
 
     void predict(bool initial) override
@@ -79,7 +79,7 @@ class ScalarSweeper
 
     void exact(complex_vector_type& q, time t)
     {
-      q[0] = this->_u0 * exp(this->_lambda * t);
+      q[0] = this->u0 * exp(this->lambda * t);
     }
 
     void exact(shared_ptr<encap_type> q_encap, time t)
@@ -96,9 +96,9 @@ class ScalarSweeper
       auto& q = pfasst::encap::as_vector<complex<double>, time>(q_encap);
 
       // f_expl = multiply with imaginary part of lambda
-      f[0] = this->i_complex * imag(this->_lambda) * q[0];
+      f[0] = this->i_complex * imag(this->lambda) * q[0];
 
-      this->_n_f_expl_eval++;
+      this->n_f_expl_eval++;
     }
 
     void f_impl_eval(shared_ptr<encap_type> f_encap,
@@ -109,9 +109,9 @@ class ScalarSweeper
       auto& q = pfasst::encap::as_vector<complex<double>, time>(q_encap);
 
       // f_impl = multiply with real part of lambda
-      f[0] = real(this->_lambda) * q[0];
+      f[0] = real(this->lambda) * q[0];
 
-      this->_n_f_impl_eval++;
+      this->n_f_impl_eval++;
     }
 
     void impl_solve(shared_ptr<encap_type> f_encap,
@@ -124,11 +124,11 @@ class ScalarSweeper
       auto& rhs = pfasst::encap::as_vector<complex<double>, time>(rhs_encap);
 
       // invert f_impl = multiply with inverse of real part of lambda
-      double inv = 1.0 / (1.0 - double(dt) * real(this->_lambda));
+      double inv = 1.0 / (1.0 - double(dt) * real(this->lambda));
       q[0] = inv * rhs[0];
-      f[0] = real(this->_lambda) * q[0];
+      f[0] = real(this->lambda) * q[0];
 
-      this->_n_impl_solve++;
+      this->n_impl_solve++;
     }
 };
 

tests/examples/scalar/test_scalar.cpp

@@ -10,11 +10,6 @@
 #include "../examples/scalar/scalar_sdc.cpp"
 #undef PFASST_UNIT_TESTING
 
-MATCHER (DoubleMore, "")
-{
-  return get<0>(arg) > get<1>(arg);
-}
-
 
 /*
  * For Lobatto nodes, the resulting method should of order 2*M-2 with M=number of nodes
@@ -23,49 +18,45 @@ MATCHER (DoubleMore, "")
  */
 TEST(ConvergenceTest, ScalarSDC)
 {
-    
   const complex<double> lambda = complex<double>(-1.0, 1.0);
   const double Tend = 4.0;
   const vector<size_t> nsteps = { 2, 5, 10, 15, 20 };
   size_t nsteps_l = nsteps.size();
 
   vector<double> err(nsteps.size());
   vector<double> convrate(nsteps.size()-1);
-    
+
   double dt;
-    
-  // Test converge up to 6 nodes: For more nodes, errors are of the order of machine 
-  // precision and convergence can no longer be monitored  
+
+  // Test converge up to 6 nodes: For more nodes, errors are of the order of machine
+  // precision and convergence can no longer be monitored
   for ( size_t nnodes = 2; nnodes<=6; ++nnodes)
   {
     // 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
     size_t niters = 2*nnodes-2;
-  
+
     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);
     }
-  
+
     for ( size_t i = 0; i<=nsteps_l-2; ++i)
     {
       convrate[i] = log10(err[i+1]/err[i])/log10(double(nsteps[i])/double(nsteps[i+1]));
-      
-      EXPECT_THAT(convrate[i], testing::DoubleNear(double(2*nnodes-2), 0.99)) << "Convergence rate at node " << i << " not within expected range";
+
+      EXPECT_THAT(convrate[i],
+                  testing::DoubleNear(double(2*nnodes-2), 0.99)) << "Convergence rate at node "
+                                                                 << i
+                                                                 << " not within expected range";
     }
-  
-    // NOTE: There is probably a much more elegant way to test this, because
-    // expected_cr contains the same value in all entries. But I could not so far figure
-    // out how to build a more clever MATCHER here so far....
-    // EXPECT_THAT(convrate, testing::Pointwise(DoubleMore(), expected_cr ));
-  
   }
 }
 
 int main(int argc, char** argv)
 {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
-}
+}