#60: update code to 0.17.0

Author: cwschilly

end-to-end-roms/cpp/lspg_pick_solver_and_run.hpp

@@ -55,7 +55,7 @@ void lspg_pick_solver_and_run(const ParserType & parser,
 			      RomStateType & reducedState)
 {
   namespace pode   = pressio::ode;
-  namespace pnlins = pressio::nonlinearsolvers;
+  namespace pnlins = pressio::nlsol;
 
   using scalar_type = typename pressio::Traits<RomStateType>::scalar_type;
   const auto startTime = static_cast<typename LspgStepperType::independent_variable_type>(0);
@@ -65,48 +65,45 @@ void lspg_pick_solver_and_run(const ParserType & parser,
   if (parser.nonlinearSolver() == "GaussNewton")
   {
   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>;
+  using solver_tag      = pressio::linsol::direct::HouseholderQR;
+  using linear_solver_t = pressio::linsol::Solver<solver_tag, hessian_t>;
   linear_solver_t linearSolver;
 
-  auto solver = pressio::create_gauss_newton_solver(lspgStepper, linearSolver);
+  auto solver = pressio::nlsol::create_gauss_newton_solver(lspgStepper, linearSolver);
   solver.setStopCriterion(pnlins::Stop::WhenAbsolutel2NormOfGradientBelowTolerance);
   solver.setStopTolerance(parser.nonlinearSolverTolerance());
 
-  pode::advance_n_steps(lspgStepper, reducedState, startTime,
-			parser.timeStepSize(), numSteps,
-			observer, solver);
+  auto policy = pode::steps_fixed_dt(startTime, numSteps, parser.timeStepSize());
+  pode::advance(lspgStepper, reducedState, policy, solver, observer);
   }
 
   else if (parser.nonlinearSolver() == "GaussNewtonQR")
   {
   using mat_t = typename LspgStepperType::jacobian_type;
   using qr_solver_t = pressio::qr::QRSolver<mat_t, pressio::qr::Householder>;
   qr_solver_t qrSolver;
-  auto solver = pressio::experimental::create_gauss_newton_qr_solver(lspgStepper, qrSolver);
+  auto solver = pressio::nlsol::experimental::create_gauss_newton_qr_solver(lspgStepper, qrSolver);
   solver.setStopCriterion(pnlins::Stop::WhenAbsolutel2NormOfGradientBelowTolerance);
   solver.setStopTolerance(parser.nonlinearSolverTolerance());
 
-  pode::advance_n_steps(lspgStepper, reducedState, startTime,
-			parser.timeStepSize(), numSteps,
-			observer, solver);
+  auto policy = pode::steps_fixed_dt(startTime, numSteps, parser.timeStepSize());
+  pode::advance(lspgStepper, reducedState, policy, solver, observer);
   }
 
   else if (parser.nonlinearSolver() == "LevenbergMarquardt")
   {
   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>;
+  using solver_tag      = pressio::linsol::direct::HouseholderQR;
+  using linear_solver_t = pressio::linsol::Solver<solver_tag, hessian_t>;
   linear_solver_t linearSolver;
 
-  auto solver = pressio::create_levenberg_marquardt_solver(lspgStepper, linearSolver);
+  auto solver = pressio::nlsol::create_levenberg_marquardt_solver(lspgStepper, linearSolver);
   solver.setUpdateCriterion(pnlins::Update::LMSchedule2);
   solver.setStopCriterion(pnlins::Stop::WhenAbsolutel2NormOfGradientBelowTolerance);
   solver.setStopTolerance(parser.nonlinearSolverTolerance());
 
-  pode::advance_n_steps(lspgStepper, reducedState, startTime,
-			parser.timeStepSize(), numSteps,
-			observer, solver);
+  auto policy = pode::steps_fixed_dt(startTime, numSteps, parser.timeStepSize());
+  pode::advance(lspgStepper, reducedState, policy, solver, observer);
   }
 }
 #endif

end-to-end-roms/cpp/main.cc

@@ -48,8 +48,7 @@
 
 #include "pressio_cmake_config.h"
 #include "pressiodemoapps/swe2d.hpp"
-#include "pressio/ode_steppers_explicit.hpp"
-#include "pressio/ode_steppers_implicit.hpp"
+#include "pressio/ode_steppers.hpp"
 #include "pressio/ode_advancers.hpp"
 
 #include "parsers.hpp"

end-to-end-roms/cpp/observer.hpp

@@ -66,7 +66,7 @@ class StateObserver
   std::enable_if_t< pressio::is_vector_eigen<ObservableType>::value >
   operator()(pressio::ode::StepCount step,
 	     const TimeType /*timeIn*/,
-	     const ObservableType & state)
+	     const ObservableType & state) const
   {
     if (step.get() % sampleFreq_ == 0){
       const std::size_t ext = state.size()*sizeof(typename ObservableType::Scalar);
@@ -75,7 +75,7 @@ class StateObserver
   }
 
 private:
-  std::ofstream myfile_;
+  mutable std::ofstream myfile_;
   const int sampleFreq_ = {};
 };
 
@@ -97,7 +97,7 @@ class RhsObserver
   operator()(pressio::ode::StepCount step,
 	     pressio::ode::IntermediateStepCount /*imStepCount*/,
 	     const TimeType /*timeIn*/,
-	     const ObservableType & rhs)
+	     const ObservableType & rhs) const
   {
     if (step.get() % sampleFreq_ == 0){
       const std::size_t ext = rhs.size()*sizeof(typename ObservableType::Scalar);
@@ -106,7 +106,7 @@ class RhsObserver
   }
 
 private:
-  std::ofstream myfile_;
+  mutable std::ofstream myfile_;
   const int sampleFreq_ = {};
 };
 

end-to-end-roms/cpp/run_default_galerkin.hpp

@@ -83,8 +83,8 @@ void run_galerkin_default(const FomSystemType & fomSystem,
 
   typename FomSystemType::time_type startTime{0};
   const auto numSteps = pode::StepCount{parser.numSteps()};
-  pode::advance_n_steps(problem, reducedState, startTime,
-			parser.timeStepSize(), numSteps, observer);
+  auto policy = pode::steps_fixed_dt(startTime, numSteps, parser.timeStepSize());
+  pode::advance(problem, reducedState, policy, observer);
   }
   else{
     throw std::runtime_error("Default implicit galerkin not impl yet");

end-to-end-roms/cpp/run_fom_explicit.hpp

@@ -49,7 +49,7 @@
 #ifndef PRESSIO_TUTORIALS_ENDTOEND_WORKFLOW_RUN_FOM_EXPLICIT_HPP_
 #define PRESSIO_TUTORIALS_ENDTOEND_WORKFLOW_RUN_FOM_EXPLICIT_HPP_
 
-#include "pressio/ode_steppers_explicit.hpp"
+#include "pressio/ode_steppers.hpp"
 #include "pressio/ode_advancers.hpp"
 #include "observer.hpp"
 
@@ -63,16 +63,14 @@ void run_fom_explicit(const FomSystemType & fomSystem,
   write_vector_to_binary(state, "initial_state.bin");
 
   const auto odeScheme = parser.odeScheme();
-  assert(pressio::ode::is_explicit_scheme(odeScheme));
+  assert(pode::is_explicit_scheme(odeScheme));
   auto stepperObj = pode::create_explicit_stepper(odeScheme, fomSystem);
 
   RhsObserver rhsObs(parser.rhsSamplingFreq());
   StateObserver stateObs(parser.stateSamplingFreq());
   const auto startTime = static_cast<typename FomSystemType::scalar_type>(0);
-  pode::advance_n_steps(stepperObj, state, startTime,
-			parser.timeStepSize(),
-			pode::StepCount(parser.numSteps()),
-			stateObs, rhsObs);
+  auto policy = pode::steps_fixed_dt(startTime, pode::StepCount(parser.numSteps()), parser.timeStepSize());
+  pode::advance(stepperObj, state, policy, stateObs, rhsObs);
 }
 
 #endif

end-to-end-roms/cpp/run_fom_implicit.hpp

@@ -49,7 +49,7 @@
 #ifndef PRESSIO_TUTORIALS_ENDTOEND_WORKFLOW_RUN_FOM_IMPLICIT_HPP_
 #define PRESSIO_TUTORIALS_ENDTOEND_WORKFLOW_RUN_FOM_IMPLICIT_HPP_
 
-#include "pressio/ode_steppers_implicit.hpp"
+#include "pressio/ode_steppers.hpp"
 #include "pressio/ode_advancers.hpp"
 #include "observer.hpp"
 
@@ -58,8 +58,8 @@ void run_fom_implicit(const FomSystemType & fomSystem,
 		      const ParserType & parser)
 {
   namespace pode   = pressio::ode;
-  namespace plins  = pressio::linearsolvers;
-  namespace pnlins = pressio::nonlinearsolvers;
+  namespace plins  = pressio::linsol;
+  namespace pnlins = pressio::nlsol;
 
   auto state = fomSystem.initialCondition();
   write_vector_to_binary(state, "initial_state.bin");
@@ -77,16 +77,14 @@ void run_fom_implicit(const FomSystemType & fomSystem,
   // nonlinear solver
   const auto nonlinSolverType = parser.nonlinearSolver();
   assert(nonlinSolverType == "NewtonRaphson");
-  auto nonLinearSolver = pressio::create_newton_solver(stepperObj, linearSolver);
+  auto nonLinearSolver = pressio::nlsol::create_newton_solver(stepperObj, linearSolver);
   nonLinearSolver.setStopTolerance(parser.nonlinearSolverTolerance());
 
   // advance in time
   StateObserver observer(parser.stateSamplingFreq());
   const auto startTime = static_cast<typename FomSystemType::scalar_type>(0);
-  pode::advance_n_steps(stepperObj, state, startTime,
-			parser.timeStepSize(),
-			pode::StepCount(parser.numSteps()),
-			observer, nonLinearSolver);
+  auto policy = pode::steps_fixed_dt(startTime, pode::StepCount(parser.numSteps()), parser.timeStepSize());
+  pode::advance(stepperObj, state, policy, nonLinearSolver, observer);
 }
 
 #endif

end-to-end-roms/cpp/run_hyperreduced_galerkin.hpp

@@ -117,8 +117,8 @@ void run_galerkin_hyperreduced(const FomSystemType & fomSystem,
 
   typename FomSystemType::time_type startTime{0};
   const auto numSteps = pode::StepCount{parser.numSteps()};
-  pode::advance_n_steps(problem, reducedState, startTime,
-			parser.timeStepSize(), numSteps, observer);
+  auto policy = pode::steps_fixed_dt(startTime, numSteps, parser.timeStepSize());
+  pode::advance(problem, reducedState, policy, observer);
   }
   else{
     throw std::runtime_error("Hyper-reduced implicit galerkin not impl yet");

version.txt

@@ -1,4 +1,4 @@
 
 VERSION_MAJOR 0
-VERSION_MINOR 16
+VERSION_MINOR 17
 VERSION_PATCH 0