Merge pull request #2 from Pressio/release-candidate-0.16.0

updating to work with pressio 0.16.0

Author: fnrizzi

include/pressio-schwarz/rom_utils.hpp

@@ -344,7 +344,7 @@ class Weigher {
         }
     }
 
-    int leadingDim() { return leading_dim; }
+    int leadingDim() const { return leading_dim; }
 
     // operator on residual
     void operator()(const Eigen::Matrix<scalar_t, -1, 1> & operand,

include/pressio-schwarz/subdomain.hpp

@@ -504,8 +504,7 @@ class SubdomainLSPG: public SubdomainROM<mesh_t, app_type, prob_t>
     using linsolver_t = pressio::linearsolvers::Solver<solver_tag, hessian_t>;
 
     using problem_t       = decltype(plspg::create_unsteady_problem(pressio::ode::StepScheme(), std::declval<trial_t&>(), std::declval<app_t&>()));
-    using stepper_t       = decltype(std::declval<problem_t>().lspgStepper());
-    using nonlinsolver_t  = decltype(pressio::create_gauss_newton_solver(std::declval<stepper_t&>(), std::declval<linsolver_t&>()));
+    using nonlinsolver_t  = decltype(pressio::create_gauss_newton_solver(std::declval<problem_t&>(), std::declval<linsolver_t&>()));
 
 public:
 
@@ -528,9 +527,8 @@ class SubdomainLSPG: public SubdomainROM<mesh_t, app_type, prob_t>
              probId, odeScheme, fluxOrder, icflag, icFileRoot, userParams,
              transRoot, basisRoot, nmodes)
     , m_problem(plspg::create_unsteady_problem(odeScheme, this->m_trialSpace, *(this->m_app)))
-    , m_stepper(m_problem.lspgStepper())
     , m_linSolverObj(std::make_shared<linsolver_t>())
-    , m_nonlinSolver(pressio::create_gauss_newton_solver(m_stepper, *m_linSolverObj))
+    , m_nonlinSolver(pressio::create_gauss_newton_solver(m_problem, *m_linSolverObj))
     {
 
         m_nonlinSolver.setStopCriterion(pressio::nonlinearsolvers::Stop::WhenAbsolutel2NormOfCorrectionBelowTolerance);
@@ -539,12 +537,11 @@ class SubdomainLSPG: public SubdomainROM<mesh_t, app_type, prob_t>
     }
 
     void doStep(pode::StepStartAt<double> startTime, pode::StepCount step, pode::StepSize<double> dt) final {
-        m_stepper(this->m_stateReduced, startTime, step, dt, m_nonlinSolver);
+        m_problem(this->m_stateReduced, startTime, step, dt, m_nonlinSolver);
     }
 
 private:
     problem_t m_problem;
-    stepper_t m_stepper;
     std::shared_ptr<linsolver_t> m_linSolverObj;
     nonlinsolver_t m_nonlinSolver;
 };
@@ -848,13 +845,11 @@ class SubdomainLSPGHyper: public SubdomainHyper<mesh_t, app_type, prob_t>
                                               std::declval<app_t&>(),
                                               std::declval<updaterHyp_t&>()));
 
-    using stepperHyp_t = std::remove_reference_t<
-        decltype(std::declval<problemHyp_t>().lspgStepper())>;
     using tag_t = pressio::nonlinearsolvers::impl::CompactWeightedGaussNewtonNormalEqTag;
 
     using nonlinsolverHyp_t =
         decltype(pressio::create_gauss_newton_solver(
-            std::declval<stepperHyp_t&>(),
+            std::declval<problemHyp_t&>(),
             std::declval<linsolver_t&>(),
             std::declval<weigh_t&>(),
             std::declval<tag_t>()
@@ -892,7 +887,7 @@ class SubdomainLSPGHyper: public SubdomainHyper<mesh_t, app_type, prob_t>
     }
 
     void doStep(pode::StepStartAt<double> startTime, pode::StepCount step, pode::StepSize<double> dt) final {
-        (*m_stepperHyper)(this->m_stateReduced, startTime, step, dt, *m_nonlinSolverHyper);
+        (*m_problemHyper)(this->m_stateReduced, startTime, step, dt, *m_nonlinSolverHyper);
     }
 
     // Again, this has to be done because the hyper-reduced mesh
@@ -915,8 +910,6 @@ class SubdomainLSPGHyper: public SubdomainHyper<mesh_t, app_type, prob_t>
                                             *(this->m_appHyper),
                                             *m_updaterHyper));
 
-        m_stepperHyper = &(m_problemHyper->lspgStepper());
-
         m_linSolverObjHyper = std::make_shared<linsolver_t>();
         m_tag = std::make_shared<tag_t>();
 
@@ -932,7 +925,7 @@ class SubdomainLSPGHyper: public SubdomainHyper<mesh_t, app_type, prob_t>
 
         m_nonlinSolverHyper = std::make_shared<nonlinsolverHyp_t>(
             pressio::create_gauss_newton_solver(
-                *m_stepperHyper, *m_linSolverObjHyper, *m_weigher, *m_tag
+                *m_problemHyper, *m_linSolverObjHyper, *m_weigher, *m_tag
             )
         );
 
@@ -948,7 +941,6 @@ class SubdomainLSPGHyper: public SubdomainHyper<mesh_t, app_type, prob_t>
     int m_nmodes_gpod;
     std::shared_ptr<updaterHyp_t> m_updaterHyper;
     std::shared_ptr<problemHyp_t> m_problemHyper;
-    stepperHyp_t * m_stepperHyper;
     std::shared_ptr<linsolver_t> m_linSolverObjHyper;
     std::shared_ptr<weigh_t> m_weigher;
     std::shared_ptr<tag_t> m_tag;

tests_cpp/eigen_2d_swe_slip_wall_implicit_hproms/lspg/main.cc

@@ -70,15 +70,14 @@ int main()
 
     // define ROM problem
     auto problem = plspg::create_unsteady_problem(scheme, trialSpaceHyp, fomSystemHyp, hrUpdater);
-    auto stepper = problem.lspgStepper();
 
     // define solver
     using hessian_t       = Eigen::Matrix<scalar_type, -1, -1>;
     using solver_tag      = pressio::linearsolvers::direct::HouseholderQR;
     using linear_solver_t = pressio::linearsolvers::Solver<solver_tag, hessian_t>;
     linear_solver_t linearSolver;
 
-    auto solver = pressio::create_gauss_newton_solver(stepper, linearSolver);
+    auto solver = pressio::create_gauss_newton_solver(problem, linearSolver);
     solver.setStopCriterion(pnlins::Stop::WhenAbsolutel2NormOfGradientBelowTolerance);
     solver.setStopTolerance(1e-5);
 
@@ -91,7 +90,7 @@ int main()
     const auto Nsteps = pressio::ode::StepCount(tf/dt);
 
     auto runtimeStart = std::chrono::high_resolution_clock::now();
-    pode::advance_n_steps(stepper, reducedState, 0.0, dt, Nsteps, Obs, solver);
+    pode::advance_n_steps(problem, reducedState, 0.0, dt, Nsteps, Obs, solver);
     auto runtimeEnd = std::chrono::high_resolution_clock::now();
     auto nsElapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(runtimeEnd - runtimeStart).count();
     double secElapsed = static_cast<double>(nsElapsed) * 1e-9;

tests_cpp/eigen_2d_swe_slip_wall_implicit_hproms_gpod/lspg/main.cc

@@ -71,10 +71,8 @@ int main()
 
     // define ROM problem
     auto problem = plspg::create_unsteady_problem(scheme, trialSpaceHyp, fomSystemHyp, hrUpdater);
-    auto stepper = problem.lspgStepper();
 
     // define solver
-    using stepper_t       = decltype(stepper);
     using hessian_t       = Eigen::Matrix<scalar_type, -1, -1>;
     using solver_tag      = pressio::linearsolvers::direct::HouseholderQR;
     using linear_solver_t = pressio::linearsolvers::Solver<solver_tag, hessian_t>;
@@ -85,7 +83,7 @@ int main()
     // Gauss-Newton with gappy POD weighting
     auto weighter = pschwarz::Weigher<scalar_type>("gappy_pod", basisfile, sampleFile, nmodes_gpod, numDofsPerCell);
     using weigher_t = decltype(weighter);
-    auto solver = pressio::create_gauss_newton_solver(stepper, linearSolver, weighter, tag);
+    auto solver = pressio::create_gauss_newton_solver(problem, linearSolver, weighter, tag);
     solver.setStopCriterion(pnlins::Stop::WhenAbsolutel2NormOfGradientBelowTolerance);
     solver.setStopTolerance(1e-5);
 
@@ -98,7 +96,7 @@ int main()
     const auto Nsteps = pressio::ode::StepCount(tf/dt);
 
     auto runtimeStart = std::chrono::high_resolution_clock::now();
-    pode::advance_n_steps(stepper, reducedState, 0.0, dt, Nsteps, Obs, solver);
+    pode::advance_n_steps(problem, reducedState, 0.0, dt, Nsteps, Obs, solver);
     auto runtimeEnd = std::chrono::high_resolution_clock::now();
     auto nsElapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(runtimeEnd - runtimeStart).count();
     double secElapsed = static_cast<double>(nsElapsed) * 1e-9;

tests_cpp/eigen_2d_swe_slip_wall_implicit_roms/lspg/main.cc

@@ -57,15 +57,14 @@ int main()
 
     // define ROM problem
     auto problem = plspg::create_unsteady_problem(scheme, trialSpace, fomSystem);
-    auto stepper = problem.lspgStepper();
 
     // define solver
     using hessian_t       = Eigen::Matrix<scalar_type, -1, -1>;
     using solver_tag      = pressio::linearsolvers::direct::HouseholderQR;
     using linear_solver_t = pressio::linearsolvers::Solver<solver_tag, hessian_t>;
     linear_solver_t linearSolver;
 
-    auto solver = pressio::create_gauss_newton_solver(stepper, linearSolver);
+    auto solver = pressio::create_gauss_newton_solver(problem, linearSolver);
     solver.setStopCriterion(pnlins::Stop::WhenAbsolutel2NormOfGradientBelowTolerance);
     solver.setStopTolerance(1e-5);
 
@@ -78,7 +77,7 @@ int main()
     const auto Nsteps = pressio::ode::StepCount(tf/dt);
 
     auto runtimeStart = std::chrono::high_resolution_clock::now();
-    pode::advance_n_steps(stepper, reducedState, 0.0, dt, Nsteps, Obs, solver);
+    pode::advance_n_steps(problem, reducedState, 0.0, dt, Nsteps, Obs, solver);
     auto runtimeEnd = std::chrono::high_resolution_clock::now();
     std::chrono::duration<double, std::milli> duration = runtimeEnd - runtimeStart;
     Obs_run(duration.count() * 1e-3);