Update template formatting for tests

Fixed extraneous divergence

Fixed extraneous divergence

Author: PhilipFackler

GridKit/CommonMath.hpp

@@ -335,6 +335,7 @@ namespace GridKit
     {
       assert(limit_min <= limit_max);
       using ScalarT = scalar_type;
+      using RealT   = real_type;
 
       ScalarT above_min = above(x, limit_min);
       ScalarT below_max = below(x, limit_max);

GridKit/LinearAlgebra/Solver/ResolveSystemSolver.hpp

@@ -13,7 +13,7 @@ namespace GridKit
   namespace LinearAlgebra
   {
     template <typename scalar_type, typename index_type>
-    class ResolveSystemSolver : public LinearSolver<ScalarT, IdxT>
+    class ResolveSystemSolver : public LinearSolver<scalar_type, index_type>
     {
     public:
       using ScalarT = scalar_type;

GridKit/Model/PhasorDynamics/Bus/BusDataJSONParser.hpp

@@ -22,8 +22,8 @@ namespace GridKit
     template <typename real_type, typename index_type>
     void from_json(const json& j, BusData<real_type, index_type>& bd)
     {
-      using RealT = real_type;
-      using IdxT  = index_type;
+      using RealT    = real_type;
+      using IdxT     = index_type;
       using BusDataT = BusData<RealT, IdxT>;
 
       j.at("name").get_to(bd.name);

GridKit/Model/PowerFlow/Generator2/Generator2.hpp

@@ -37,10 +37,10 @@ namespace GridKit
     using ModelEvaluatorImpl<scalar_type, index_type>::param_lo_;
 
   public:
-    using ScalarT  = scalar_type;
-    using IdxT     = index_type;
-    using RealT    = typename ModelEvaluatorImpl<ScalarT, IdxT>::RealT;
-    using BusT = BaseBus<ScalarT, IdxT>;
+    using ScalarT = scalar_type;
+    using IdxT    = index_type;
+    using RealT   = typename ModelEvaluatorImpl<ScalarT, IdxT>::RealT;
+    using BusT    = BaseBus<ScalarT, IdxT>;
 
     Generator2(BusT* bus);
     virtual ~Generator2();

GridKit/Solver/Dynamic/Ida.cpp

@@ -266,7 +266,7 @@ namespace AnalysisManager
      * repeated time-step arithmetic.
      */
     template <typename scalar_type, typename index_type>
-    typename Ida<scalar_type, index_type>::RealT Ida<scalar_type, IdxT>::getMonitorTime(RealT tf, RealT dt_monitor, int step, int nsteps) const
+    typename Ida<scalar_type, index_type>::RealT Ida<scalar_type, index_type>::getMonitorTime(RealT tf, RealT dt_monitor, int step, int nsteps) const
     {
       return step == nsteps ? tf : std::fma((RealT) step, dt_monitor, t_init_);
     }

GridKit/Solver/Dynamic/Ida.hpp

@@ -43,7 +43,7 @@ namespace AnalysisManager
     template <typename scalar_type, typename index_type>
     class Ida : public DynamicSolver<scalar_type, index_type>
     {
-      using DynamicSolver<ScalarT, IdxT>::model_;
+      using DynamicSolver<scalar_type, index_type>::model_;
 
     public:
       using ScalarT    = scalar_type;

GridKit/Solver/Dynamic/Native/FixedStep.hpp

@@ -17,6 +17,8 @@ namespace AnalysisManager
     template <typename real_type>
     class FixedStep : public StepController<real_type>
     {
+      using RealT = real_type;
+
       StepControl<RealT> nextStep(RealT err, StepControl<RealT> prev_step, uint8_t method_order) final;
 
       /**

GridKit/Solver/Dynamic/Rosenbrock.cpp

@@ -229,11 +229,11 @@ namespace AnalysisManager
      */
     template <typename scalar_type, typename index_type>
     Rosenbrock<scalar_type, index_type>::Rosenbrock(Tableau&&                                             tab,
-                                          GridKit::Model::Evaluator<ScalarT, IdxT>*             model,
-                                          GridKit::LinearAlgebra::LinearSolver<ScalarT, IdxT>&  lin_solver,
-                                          GridKit::LinearAlgebra::VectorHandler<ScalarT, IdxT>& vector_handler,
-                                          const ErrorNorm<ScalarT, IdxT>*                       err_norm,
-                                          GridKit::memory::MemorySpace                          memspace)
+                                                    GridKit::Model::Evaluator<ScalarT, IdxT>*             model,
+                                                    GridKit::LinearAlgebra::LinearSolver<ScalarT, IdxT>&  lin_solver,
+                                                    GridKit::LinearAlgebra::VectorHandler<ScalarT, IdxT>& vector_handler,
+                                                    const ErrorNorm<ScalarT, IdxT>*                       err_norm,
+                                                    GridKit::memory::MemorySpace                          memspace)
       : tab_(std::move(tab)),
         model_(model),
         lin_solver_(lin_solver),
@@ -401,10 +401,10 @@ namespace AnalysisManager
      */
     template <typename scalar_type, typename index_type>
     int Rosenbrock<scalar_type, index_type>::integrate(const std::vector<RealT>&                           out_times,
-                                             StepController<RealT>&                              step_controller,
-                                             Parameters                                          params,
-                                             std::optional<std::function<void(RealT)>>           out_cb,
-                                             std::optional<std::function<void(const StepInfo&)>> step_cb)
+                                                       StepController<RealT>&                              step_controller,
+                                                       Parameters                                          params,
+                                                       std::optional<std::function<void(RealT)>>           out_cb,
+                                                       std::optional<std::function<void(const StepInfo&)>> step_cb)
     {
       constexpr RealT ONE  = GridKit::ONE<RealT>;
       constexpr RealT ZERO = GridKit::ZERO<RealT>;
@@ -781,7 +781,7 @@ namespace AnalysisManager
      * @return A reference to the estimated error.
      */
     template <typename scalar_type, typename index_type>
-    Rosenbrock<scalar_type, index_type>::State& Rosenbrock<ScalarT, IdxT>::errorEstimate() const
+    Rosenbrock<scalar_type, index_type>::State& Rosenbrock<scalar_type, index_type>::errorEstimate() const
     {
       // Test to see if the tableau allows us to use a stage as the error estimate,
       // avoiding extra computation.

GridKit/Solver/Optimization/DynamicConstraint.hpp

@@ -25,7 +25,7 @@ namespace AnalysisManager
      *
      */
     template <typename scalar_type, typename index_type>
-    class DynamicConstraint : public Ipopt::TNLP, public OptimizationSolver<ScalarT, IdxT>
+    class DynamicConstraint : public Ipopt::TNLP, public OptimizationSolver<scalar_type, index_type>
     {
       using OptimizationSolver<scalar_type, index_type>::integrator_;
       using OptimizationSolver<scalar_type, index_type>::model_;

GridKit/Utilities/FileIO.hpp

@@ -34,7 +34,7 @@ namespace GridKit
    */
   template <typename scalar_type>
   void setLookupTable(std::vector<std::vector<scalar_type>>& table,
-                      std::istream&                      idata,
+                      std::istream&                          idata,
                       scalar_type&                           ti,
                       scalar_type&                           tf)
   {