removed the remnant of exact-time (#695)

removes the remnant of the exact time function

src/adapt.hpp

@@ -52,7 +52,7 @@ class distributed_grid
   {
     return this->get_initial_condition(
         pde.get_dimensions(),
-        pde.has_analytic_soln() ? pde.exact_time()(0.0) : static_cast<P>(1.0),
+        pde.has_exact_time() ? pde.exact_time(0.0) : static_cast<P>(1.0),
         pde.num_terms(), pde.get_terms(), transformer, cli_opts);
   }
 

src/pde/pde_advection1.hpp

@@ -19,7 +19,7 @@ class PDE_advection_1d : public PDE<P>
 public:
   PDE_advection_1d(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_)
   {}
 
@@ -65,16 +65,9 @@ class PDE_advection_1d : public PDE<P>
     return fx;
   }
 
-  static P exact_time(P const time)
-  {
-    ignore(time);
-    return 1.0;
-  }
-
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {
       exact_solution_dim0};
 
-  inline static scalar_func<P> const exact_scalar_func_ = exact_time;
   // =========================================================================
 
   // Sources =================================================================

src/pde/pde_base.hpp

@@ -556,22 +556,22 @@ class PDE
       int const max_num_terms, std::vector<dimension<P>> const dimensions,
       term_set<P> const terms, std::vector<source<P>> const sources_in,
       std::vector<vector_func<P>> const exact_vector_funcs_in,
-      scalar_func<P> const exact_time_in, dt_func<P> const get_dt,
+      dt_func<P> const get_dt,
       bool const do_poisson_solve_in          = false,
       bool const has_analytic_soln_in         = false,
       std::vector<moment<P>> const moments_in = {},
       bool const do_collision_operator_in     = true)
       : PDE(cli_input, num_dims_in, num_sources_in, max_num_terms, dimensions,
             terms, sources_in,
             std::vector<md_func_type<P>>({exact_vector_funcs_in}),
-            exact_time_in, get_dt, do_poisson_solve_in, has_analytic_soln_in,
+            get_dt, do_poisson_solve_in, has_analytic_soln_in,
             moments_in, do_collision_operator_in)
   {}
   PDE(parser const &cli_input, int const num_dims_in, int const num_sources_in,
       int const max_num_terms, std::vector<dimension<P>> dimensions,
       term_set<P> terms, std::vector<source<P>> sources_in,
       std::vector<md_func_type<P>> exact_vector_funcs_in,
-      scalar_func<P> exact_time_in, dt_func<P> get_dt,
+      dt_func<P> get_dt,
       bool const do_poisson_solve_in      = false,
       bool const has_analytic_soln_in     = false,
       std::vector<moment<P>> moments_in   = {},
@@ -580,7 +580,7 @@ class PDE
     initialize(cli_input, num_dims_in, num_sources_in,
       max_num_terms, std::move(dimensions), std::move(terms), std::move(sources_in),
       std::move(exact_vector_funcs_in),
-      std::move(exact_time_in), std::move(get_dt),
+      std::move(get_dt),
       do_poisson_solve_in,
       has_analytic_soln_in,
       std::move(moments_in),
@@ -591,7 +591,7 @@ class PDE
       int const max_num_terms, std::vector<dimension<P>> const &dimensions,
       term_set<P> const &terms, std::vector<source<P>> const &sources_in,
       std::vector<md_func_type<P>> const &exact_vector_funcs_in,
-      scalar_func<P> const &exact_time_in, dt_func<P> const &get_dt,
+      dt_func<P> const &get_dt,
       bool const do_poisson_solve_in           = false,
       bool const has_analytic_soln_in          = false,
       std::vector<moment<P>> const &moments_in = {},
@@ -601,7 +601,7 @@ class PDE
                      std::vector<dimension<P>>(dimensions), term_set<P>(terms),
                      std::vector<source<P>>(sources_in),
                      std::vector<md_func_type<P>>(exact_vector_funcs_in),
-                     scalar_func<P>(exact_time_in), dt_func<P>(get_dt), do_poisson_solve_in,
+                     dt_func<P>(get_dt), do_poisson_solve_in,
                      has_analytic_soln_in, std::vector<moment<P>>(moments_in),
                      do_collision_operator_in);
   }
@@ -610,7 +610,7 @@ class PDE
       int const max_num_terms, std::vector<dimension<P>> &&dimensions,
       term_set<P> &&terms, std::vector<source<P>> &&sources_in,
       std::vector<md_func_type<P>> &&exact_vector_funcs_in,
-      scalar_func<P> &&exact_time_in, dt_func<P> &&get_dt,
+      dt_func<P> &&get_dt,
       bool const do_poisson_solve_in      = false,
       bool const has_analytic_soln_in     = false,
       std::vector<moment<P>> &&moments_in = {},
@@ -625,8 +625,6 @@ class PDE
     exact_vector_funcs_ = std::move(exact_vector_funcs_in);
     moments             = std::move(moments_in);
 
-    exact_time_ = check_exact_time(std::move(exact_time_in));
-
     do_poisson_solve_      = do_poisson_solve_in;
     do_collision_operator_ = do_collision_operator_in;
     has_analytic_soln_     = has_analytic_soln_in;
@@ -814,7 +812,6 @@ class PDE
       : moments(pde.moments), num_dims_(1), num_sources_(pde.sources_.size()),
         num_terms_(pde.get_terms().size()), max_level_(pde.max_level_),
         sources_(pde.sources_), exact_vector_funcs_(pde.exact_vector_funcs_),
-        exact_time_(pde.exact_time()),
         do_poisson_solve_(pde.do_poisson_solve()),
         do_collision_operator_(pde.do_collision_operator()),
         has_analytic_soln_(pde.has_analytic_soln()),
@@ -832,9 +829,18 @@ class PDE
   {
     return exact_vector_funcs_;
   }
+  bool has_exact_time() const
+  {
+    return has_analytic_soln_ and
+        static_cast<int>(exact_vector_funcs_.back().size()) == num_dims_ + 1;
+  }
+  P exact_time(P time) const
+  {
+    fk::vector<P> dummy;
+    return exact_vector_funcs_.back().back()(dummy, time)[0];
+  }
 
   std::vector<moment<P>> moments;
-  scalar_func<P> const& exact_time() const { return exact_time_; }
   bool do_poisson_solve() const { return do_poisson_solve_; }
   bool do_collision_operator() const { return do_collision_operator_; }
   bool has_analytic_soln() const { return has_analytic_soln_; }
@@ -1017,22 +1023,6 @@ class PDE
     }
   }
 
-  scalar_func<P> check_exact_time(scalar_func<P> &&exact_time_func)
-  {
-    // check if the PDE exact time function was defined, or return an empty one
-    if (!exact_time_func)
-    {
-      return [](P const t) {
-        ignore(t);
-        return P{1.0};
-      };
-    }
-    else
-    {
-      return std::move(exact_time_func);
-    }
-  }
-
   int num_dims_;
   int num_sources_;
   int num_terms_;
@@ -1041,7 +1031,6 @@ class PDE
   std::vector<source<P>> sources_;
   std::vector<md_func_type<P>> exact_vector_funcs_;
 
-  scalar_func<P> exact_time_;
   bool do_poisson_solve_;
   bool do_collision_operator_;
   bool has_analytic_soln_;

src/pde/pde_collisional_landau.hpp

@@ -16,7 +16,7 @@ class PDE_collisional_landau : public PDE<P>
 public:
   PDE_collisional_landau(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_, moments_,
                do_collision_operator_)
   {
@@ -479,7 +479,6 @@ class PDE_collisional_landau : public PDE<P>
                                             terms_7, terms_8, terms_9};
 
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {};
-  inline static scalar_func<P> const exact_scalar_func_               = {};
 
   static P get_dt_(dimension<P> const &dim)
   {

src/pde/pde_collisional_landau_1x2v.hpp

@@ -16,7 +16,7 @@ class PDE_collisional_landau_1x2v : public PDE<P>
 public:
   PDE_collisional_landau_1x2v(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_, moments_,
                do_collision_operator_)
   {
@@ -503,8 +503,6 @@ class PDE_collisional_landau_1x2v : public PDE<P>
 
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {};
 
-  inline static scalar_func<P> const exact_scalar_func_ = {};
-
   static P get_dt_(dimension<P> const &dim)
   {
     ignore(dim);

src/pde/pde_collisional_landau_1x3v.hpp

@@ -16,7 +16,7 @@ class PDE_collisional_landau_1x3v : public PDE<P>
 public:
   PDE_collisional_landau_1x3v(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_, moments_,
                do_collision_operator_)
   {
@@ -555,8 +555,6 @@ class PDE_collisional_landau_1x3v : public PDE<P>
 
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {};
 
-  inline static scalar_func<P> const exact_scalar_func_ = {};
-
   static P get_dt_(dimension<P> const &dim)
   {
     ignore(dim);

src/pde/pde_continuity1.hpp

@@ -38,7 +38,7 @@ class PDE_continuity_1d : public PDE<P>
 public:
   PDE_continuity_1d(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_)
   {}
 
@@ -78,13 +78,11 @@ class PDE_continuity_1d : public PDE<P>
     return fx;
   }
 
-  static P exact_time(P const time) { return std::sin(time); }
-
-  static fk::vector<P> exact_time_v(fk::vector<P> x, P const time)
+  static fk::vector<P> exact_time(fk::vector<P>, P const time)
   {
-    x.resize(1);
-    x[0] = exact_time(time);
-    return x;
+    return {
+        std::sin(time),
+    };
   }
 
   // specify source functions...
@@ -166,8 +164,6 @@ class PDE_continuity_1d : public PDE<P>
 
   // define exact soln functions
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {
-      exact_solution_dim0, exact_time_v};
-
-  inline static scalar_func<P> const exact_scalar_func_ = exact_time;
+      exact_solution_dim0, exact_time};
 };
 } // namespace asgard

src/pde/pde_continuity2.hpp

@@ -27,7 +27,7 @@ class PDE_continuity_2d : public PDE<P>
 public:
   PDE_continuity_2d(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_)
   {}
 
@@ -84,13 +84,11 @@ class PDE_continuity_2d : public PDE<P>
     return fx;
   }
 
-  static P exact_time(P const time) { return std::sin(2.0 * time); }
-
-  static fk::vector<P> exact_time_v(fk::vector<P> x, P const time)
+  static fk::vector<P> exact_time(fk::vector<P>, P const time)
   {
-    x.resize(1);
-    x[0] = exact_time(time);
-    return x;
+    return {
+        std::sin(P{2.0} * time),
+    };
   }
 
   // specify source functions...
@@ -261,8 +259,6 @@ class PDE_continuity_2d : public PDE<P>
 
   // define exact soln
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {
-      exact_solution_dim0, exact_solution_dim1, exact_time_v};
-
-  inline static scalar_func<P> const exact_scalar_func_ = exact_time;
+      exact_solution_dim0, exact_solution_dim1, exact_time};
 };
 } // namespace asgard

src/pde/pde_continuity3.hpp

@@ -30,7 +30,7 @@ class PDE_continuity_3d : public PDE<P>
 public:
   PDE_continuity_3d(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_)
   {}
 
@@ -94,13 +94,11 @@ class PDE_continuity_3d : public PDE<P>
     return fx;
   }
 
-  static P exact_time(P const time) { return std::sin(2.0 * time); }
-
-  static fk::vector<P> exact_time_v(fk::vector<P> x, P const time)
+  static fk::vector<P> exact_time(fk::vector<P>, P const time)
   {
-    x.resize(1);
-    x[0] = exact_time(time);
-    return x;
+    return {
+        std::sin(P{2.0} * time),
+    };
   }
 
   // specify source functions...
@@ -355,8 +353,6 @@ class PDE_continuity_3d : public PDE<P>
 
   // define exact soln
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {
-      exact_solution_dim0, exact_solution_dim1, exact_solution_dim2, exact_time_v};
-
-  inline static scalar_func<P> const exact_scalar_func_ = exact_time;
+      exact_solution_dim0, exact_solution_dim1, exact_solution_dim2, exact_time};
 };
 } // namespace asgard

src/pde/pde_continuity6.hpp

@@ -27,7 +27,7 @@ class PDE_continuity_6d : public PDE<P>
 public:
   PDE_continuity_6d(parser const &cli_input)
       : PDE<P>(cli_input, num_dims_, num_sources_, num_terms_, dimensions_,
-               terms_, sources_, exact_vector_funcs_, exact_scalar_func_,
+               terms_, sources_, exact_vector_funcs_,
                get_dt_, do_poisson_solve_, has_analytic_soln_)
   {}
 
@@ -124,19 +124,17 @@ class PDE_continuity_6d : public PDE<P>
     return fx;
   }
 
-  static P exact_time(P const time) { return std::sin(targ * time); }
-
-  static fk::vector<P> exact_time_v(fk::vector<P> x, P const time)
+  static fk::vector<P> exact_time(fk::vector<P>, P const time)
   {
-    x.resize(1);
-    x[0] = exact_time(time);
-    return x;
+    return {
+        std::sin(targ * time),
+    };
   }
 
   // define exact soln
   inline static std::vector<vector_func<P>> const exact_vector_funcs_ = {
       exact_solution_x, exact_solution_y, exact_solution_z,
-      exact_solution_vx, exact_solution_vy, exact_solution_vz, exact_time_v};
+      exact_solution_vx, exact_solution_vy, exact_solution_vz, exact_time};
 
   // specify source functions...
 
@@ -797,7 +795,5 @@ class PDE_continuity_6d : public PDE<P>
   /* this corresponds to the aggregation of TERM_ND objects in matlab */
   inline static term_set<P> const terms_ = {terms0_, terms1_, terms2_,
                                             terms3_, terms4_, terms5_};
-
-  inline static scalar_func<P> const exact_scalar_func_ = exact_time;
 };
 } // namespace asgard