examples: scalar: a few little cleanups

Signed-off-by: Torbjörn Klatt <[email protected]>

Author: torbjoernk

examples/scalar/scalar_sdc.cpp

@@ -9,7 +9,7 @@
  * explicitly.
  *
  */
- 
+
 #include<complex>
 
 #include<pfasst.hpp>
@@ -23,26 +23,22 @@ double run_scalar_sdc(const size_t nsteps, const double dt, const size_t nnodes,
                       const pfasst::QuadratureType nodetype)
 {
   pfasst::SDC<> sdc;
-  
-  /*
-   * For test equation, set initial value to \\( 1+0i )\\
-   */
+
+  // For test equation, set initial value to \\( 1+0i \\)
   const complex<double> y0 = complex<double>(1.0, 0.0);
 
   auto nodes = pfasst::compute_nodes(nnodes, nodetype);
-  
-  /*
-   * This is a scalar example, so we use the encap::VectorFactory with fixed
-   * length of 1 and complex type.
-   */
+
+  // This is a scalar example, so we use the encap::VectorFactory with fixed length of 1 and 
+  //  complex type.
   auto factory = make_shared<pfasst::encap::VectorFactory<complex<double>>>(1);
   auto sweeper = make_shared<ScalarSweeper<>>(lambda, y0);
 
   sweeper->set_nodes(nodes);
   sweeper->set_factory(factory);
 
   sdc.add_level(sweeper);
-  
+
   // Final time Tend = dt*nsteps
   sdc.set_duration(0.0, dt*nsteps, dt, niters);
   sdc.setup();
@@ -67,7 +63,7 @@ int main(int /*argc*/, char** /*argv*/)
   const size_t niters = 6;
   const complex<double> lambda = complex<double>(-1.0, 1.0);
   const pfasst::QuadratureType nodetype = pfasst::QuadratureType::GaussLobatto;
-  
+
   run_scalar_sdc(nsteps, dt, nnodes, niters, lambda, nodetype);
 }
 #endif

examples/scalar/scalar_sweeper.hpp

@@ -9,8 +9,6 @@
 
 using namespace std;
 
-template<typename time = pfasst::time_precision>
-
 /**
  * Sweeper for scalar test equation
  *
@@ -19,42 +17,41 @@ template<typename time = pfasst::time_precision>
  * with complex lambda using an IMEX scheme. Derived from the generic imex_sweeper.
  *
  */
+template<typename time = pfasst::time_precision>
 class ScalarSweeper
   : public pfasst::encap::IMEXSweeper<time>
 {
-
   private:
     typedef pfasst::encap::Encapsulation<time> encap_type;
-    
+
     //! Define a type for a complex PFASST vector encapsulation.
     typedef pfasst::encap::VectorEncapsulation<complex<double>> complex_vector_type;
-    
-     //! Parameter lambda and initial value u0 
+
+     //! Parameter lambda and initial value \\( u_0 \\)
     complex<double> lambda, u0;
-    
-    //! The complex unit i = sqrt(-1)
-    complex<double> i_complex = complex<double>(0, 1);
-    
+
+    //! The complex unit \\( i = \\sqrt{-1} \\)
+    const complex<double> i_complex = complex<double>(0, 1);
+
      //! Error at the final time. For the scalar example, an analytical solution is known.
     double error;
-    
-     //! Counters for how often f_expl_eval, f_impl_eval and impl_solve are called.
+
+     //! Counters for how often `f_expl_eval`, `f_impl_eval` and `impl_solve` are called.
     size_t n_f_expl_eval, n_f_impl_eval, n_impl_solve;
 
   public:
-  
     /**
      * Generic constructor; initialize all function call counters with zero.
      * @param[in] lambda coefficient in test equation
-     * @param[in] u0initial value at \\( t=0 \\)
+     * @param[in] u0 initial value at \\( t=0 \\)
      */ 
-    ScalarSweeper(const complex<double> lambda, const complex<double> u0)
+    ScalarSweeper(const complex<double>& lambda, const complex<double>& u0)
       :   lambda(lambda)
         , u0(u0)
+        , error(0.0)
         , n_f_expl_eval(0)
         , n_f_impl_eval(0)
         , n_impl_solve(0)
-        , error(0.0)
     {}
 
     /**
@@ -70,7 +67,8 @@ class ScalarSweeper
 
     /**
      * Compute error between last state and exact solution at time tand print it to cout
-     * @param[in] Time t
+     *
+     * @param[in] t Time
      */
     void echo_error(time t)
     {
@@ -115,9 +113,9 @@ class ScalarSweeper
     }
 
     /**
-     * Computes the exact solution \\( u_0 \\exp \\left( \\lambda*t \\right) \\) 
-     * at a given time t.
-     * @param[in] Time t
+     * Computes the exact solution \\( u_0 \\exp \\left( \\lambda*t \\right) \\) at a given time t.
+     *
+     * @param[in] t Time
      */
     void exact(complex_vector_type& q, time t)
     {
@@ -131,8 +129,7 @@ class ScalarSweeper
     }
 
     /**
-     * Evaluate the explicit part of the right hand side: Multiply with 
-     * \\( \\text{imag}(\\lambda) \\)
+     * Evaluate the explicit part of the right hand side: Multiply with \\( \\text{imag}(\\lambda) \\)
      */
     void f_expl_eval(shared_ptr<encap_type> f_encap,
                      shared_ptr<encap_type> q_encap, time t) override
@@ -148,8 +145,7 @@ class ScalarSweeper
     }
 
     /**
-     * Evaluate the implicit part of the right hand side: Multiply with 
-     * \\( \\text{real}(\\lambda) \\)
+     * Evaluate the implicit part of the right hand side: Multiply with \\( \\text{real}(\\lambda) \\)
      */
     void f_impl_eval(shared_ptr<encap_type> f_encap,
                      shared_ptr<encap_type> q_encap, time t) override
@@ -181,7 +177,7 @@ class ScalarSweeper
       // invert f_impl = multiply with inverse of real part of lambda
       double inv = 1.0 / (1.0 - double(dt) * real(this->lambda));
       q[0] = inv * rhs[0];
-      
+
       // compute f_impl_eval of q[0], i.e. multiply with real(lambda)
       f[0] = real(this->lambda) * q[0];