From bdca2fbcb690f18b61c12461f2a9dfa4258c5f63 Mon Sep 17 00:00:00 2001
From: Nicholson Koukpaizan <koukpaizannk@ornl.gov>
Date: Thu, 10 Sep 2026 14:58:59 -0400
Subject: [PATCH 1/6] Move PowerElectronics models to a namespace.

---
 GridKit/Model/PowerElectronics/CMakeLists.txt |    1 -
 .../PowerElectronics/Capacitor/Capacitor.cpp  |  284 ++--
 .../PowerElectronics/Capacitor/Capacitor.hpp  |  104 +-
 .../PowerElectronics/CircuitComponent.hpp     | 1311 +++++++++--------
 .../Model/PowerElectronics/CircuitGraph.hpp   |  123 --
 .../Model/PowerElectronics/CircuitNode.hpp    |  597 ++++----
 .../DistributedGenerator.cpp                  |  777 +++++-----
 .../DistributedGenerator.hpp                  |  192 +--
 .../PowerElectronics/ExternalConnection.hpp   |   37 +-
 .../InductionMotor/InductionMotor.cpp         |  308 ++--
 .../InductionMotor/InductionMotor.hpp         |  116 +-
 .../PowerElectronics/Inductor/Inductor.cpp    |  308 ++--
 .../PowerElectronics/Inductor/Inductor.hpp    |  112 +-
 .../LinearTransformer/LinearTransformer.cpp   |  278 ++--
 .../LinearTransformer/LinearTransformer.hpp   |  112 +-
 .../MicrogridBusDQ/MicrogridBusDQ.cpp         |  314 ++--
 .../MicrogridBusDQ/MicrogridBusDQ.hpp         |  110 +-
 .../MicrogridLine/MicrogridLine.cpp           |  377 ++---
 .../MicrogridLine/MicrogridLine.hpp           |  116 +-
 .../MicrogridLoad/MicrogridLoad.cpp           |  359 ++---
 .../MicrogridLoad/MicrogridLoad.hpp           |  114 +-
 .../PowerElectronics/Resistor/Resistor.cpp    |  286 ++--
 .../PowerElectronics/Resistor/Resistor.hpp    |  112 +-
 .../SynchronousMachine/SynchronousMachine.cpp |  377 ++---
 .../SynchronousMachine/SynchronousMachine.hpp |  128 +-
 .../SystemModelPowerElectronics.hpp           |  833 +++++------
 .../TransmissionLine/TransmissionLine.cpp     |  419 +++---
 .../TransmissionLine/TransmissionLine.hpp     |  116 +-
 .../VoltageSource/VoltageSource.cpp           |  292 ++--
 .../VoltageSource/VoltageSource.hpp           |  112 +-
 .../DistributedGeneratorTest/DGTest.cpp       |    6 +-
 .../ExamplesHelper/MicrogridNetwork.hpp       |   10 +-
 .../ExamplesHelper/SystemAssembler.hpp        |    4 +-
 .../PowerElectronics/Microgrid/Microgrid.cpp  |    2 +-
 .../PowerElectronics/RLCircuit/RLCircuit.cpp  |    9 +-
 .../ScaleMicrogrid/ScaleMicrogrid.cpp         |    2 +-
 .../ScaleMicrogridArbitrary.cpp               |    2 +-
 .../PowerElectronics/CircuitNodeTests.hpp     |    9 +-
 .../PowerElectronics/ComponentCloneTests.hpp  |   12 +-
 39 files changed, 4318 insertions(+), 4463 deletions(-)
 delete mode 100644 GridKit/Model/PowerElectronics/CircuitGraph.hpp

diff --git a/GridKit/Model/PowerElectronics/CMakeLists.txt b/GridKit/Model/PowerElectronics/CMakeLists.txt
index c985d69d6..e606e1be8 100644
--- a/GridKit/Model/PowerElectronics/CMakeLists.txt
+++ b/GridKit/Model/PowerElectronics/CMakeLists.txt
@@ -25,7 +25,6 @@ add_subdirectory(MicrogridBusDQ)
 install(
   FILES CircuitComponent.hpp
         CircuitNode.hpp
-        CircuitGraph.hpp
         SystemModelPowerElectronics.hpp
         NodeBase.hpp
         ExternalConnection.hpp
diff --git a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp
index 7d53e309f..414fbb5d9 100644
--- a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp
+++ b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp
@@ -1,5 +1,4 @@
 
-
 #include "Capacitor.hpp"
 
 #include <cmath>
@@ -8,146 +7,147 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for Capacitor
-   *
-   * @todo this needs to be tested on some circuit
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   */
-
-  template <class ScalarT, typename IdxT>
-  Capacitor<ScalarT, IdxT>::Capacitor(IdxT id, RealT C)
-    : C_(C)
-  {
-    size_           = 3;
-    n_intern_       = 1;
-    n_extern_       = 2;
-    extern_indices_ = {0, 1};
-    idc_            = id;
-    nnz_            = 5;
-  }
-
-  template <class ScalarT, typename IdxT>
-  Capacitor<ScalarT, IdxT>::~Capacitor()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Evaluate the resisdual of the Capcitor
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    f_int_[0] = -C_ * yp_int_[0] + *y_ext_[0] - *y_ext_[1] - y_int_[0];
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // input
-    *f_ext_[0] += C_ * yp_int_[0];
-    // output
-    *f_ext_[1] += -C_ * yp_int_[0];
-    return 0;
-  }
-
-  /**
-   * @brief Compute the Jacobian dF/dy - a dF/dy'
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::evaluateJacobian()
+  namespace PowerElectronics
   {
-    this->zeroJacMatrix();
-    // Create dF/dy
-    std::vector<IdxT>  rcord{0, 1, 2, 2, 2};
-    std::vector<IdxT>  ccord{2, 2, 0, 1, 2};
-    std::vector<RealT> vals{C_ * alpha_, -C_ * alpha_, 1.0, -1.0, -1.0 - C_ * alpha_};
-    this->setJacValues(rcord, ccord, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Capacitor<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* Capacitor<ScalarT, IdxT>::clone() const
-  {
-    return new Capacitor<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class Capacitor<double, long int>;
-  template class Capacitor<double, size_t>;
-  template class Capacitor<DependencyTracking::Variable, long int>;
-  template class Capacitor<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for Capacitor
+     *
+     * @todo this needs to be tested on some circuit
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     */
+    template <class ScalarT, typename IdxT>
+    Capacitor<ScalarT, IdxT>::Capacitor(IdxT id, RealT C)
+      : C_(C)
+    {
+      size_           = 3;
+      n_intern_       = 1;
+      n_extern_       = 2;
+      extern_indices_ = {0, 1};
+      idc_            = id;
+      nnz_            = 5;
+    }
+
+    template <class ScalarT, typename IdxT>
+    Capacitor<ScalarT, IdxT>::~Capacitor()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Evaluate the resisdual of the Capcitor
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      f_int_[0] = -C_ * yp_int_[0] + *y_ext_[0] - *y_ext_[1] - y_int_[0];
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // input
+      *f_ext_[0] += C_ * yp_int_[0];
+      // output
+      *f_ext_[1] += -C_ * yp_int_[0];
+      return 0;
+    }
+
+    /**
+     * @brief Compute the Jacobian dF/dy - a dF/dy'
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+      // Create dF/dy
+      std::vector<IdxT>  rcord{0, 1, 2, 2, 2};
+      std::vector<IdxT>  ccord{2, 2, 0, 1, 2};
+      std::vector<RealT> vals{C_ * alpha_, -C_ * alpha_, 1.0, -1.0, -1.0 - C_ * alpha_};
+      this->setJacValues(rcord, ccord, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Capacitor<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* Capacitor<ScalarT, IdxT>::clone() const
+    {
+      return new Capacitor<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class Capacitor<double, long int>;
+    template class Capacitor<double, size_t>;
+    template class Capacitor<DependencyTracking::Variable, long int>;
+    template class Capacitor<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp
index 201597fa0..009888882 100644
--- a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp
+++ b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp
@@ -1,70 +1,66 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a Capacitor class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class Capacitor : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+    /*!
+     * @brief Declaration of a Capacitor class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class Capacitor : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    Capacitor(IdxT id, RealT C);
-    virtual ~Capacitor();
+    public:
+      Capacitor(IdxT id, RealT C);
+      virtual ~Capacitor();
 
-    int initialize();
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT C_;
-  };
+    private:
+      RealT C_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/CircuitComponent.hpp b/GridKit/Model/PowerElectronics/CircuitComponent.hpp
index c3e33792a..bed8a983e 100644
--- a/GridKit/Model/PowerElectronics/CircuitComponent.hpp
+++ b/GridKit/Model/PowerElectronics/CircuitComponent.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <cassert>
@@ -14,774 +13,776 @@
 
 namespace GridKit
 {
-  /*!
-   * @brief Declaration of a CircuitComponent class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class CircuitComponent : public Model::Evaluator<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-  public:
-    using RealT      = typename Model::Evaluator<ScalarT, IdxT>::RealT;
-    using CsrMatrixT = typename Model::Evaluator<ScalarT, IdxT>::CsrMatrixT;
-    using VectorT    = typename Model::Evaluator<ScalarT, IdxT>::VectorT;
-
-    CircuitComponent() = default;
-
-  protected:
-    /**
-     * @brief Constructs a copy of a circuit component.
-     *
-     * Copies the component metadata, local vector data, connection-node mapping,
-     * and COO Jacobian storage. Dynamically allocated component-owned data is
-     * deep-copied so that the new component does not share ownership of this
-     * storage with @p other.
-     *
-     * Pointers to state, state-derivative, and residual storage supplied by a
-     * parent system are copied as-is. Consequently, the copied component initially
-     * references the same parent-system storage as @p other. The pointer arrays
-     * used for external variables are independently allocated, but their entries
-     * point to the same external state, state-derivative, and residual storage as
-     * the original component.
+    /*!
+     * @brief Declaration of a CircuitComponent class.
      *
-     * Local vectors, including the state, state derivative, residual, tolerances,
-     * quadrature data, adjoint data, and parameter vectors, retain the values of
-     * the original component.
-     *
-     * @param other Component to copy.
-     *
-     * @note If the copied component is subsequently attached to a different parent
-     *       system, its state, state-derivative, and residual pointers must be
-     *       reassigned to the storage provided by that system before evaluation.
      */
-    CircuitComponent(const CircuitComponent& other)
-      : n_extern_(other.n_extern_),
-        n_intern_(other.n_intern_),
-        extern_indices_(other.extern_indices_),
-        size_(other.size_),
-        nnz_(other.nnz_),
-        size_quad_(other.size_quad_),
-        size_opt_(other.size_opt_),
-        current_jac_size_(other.current_jac_size_),
-        y_int_(other.y_int_),
-        yp_int_(other.yp_int_),
-        f_int_(other.f_int_),
-        tag_(other.tag_),
-        time_(other.time_),
-        alpha_(other.alpha_),
-        max_steps_(other.max_steps_),
-        idc_(other.idc_),
-        allocated_(other.allocated_)
-    {
-
-      auto copyVector = [](VectorT& destination, const VectorT& source)
+    template <class ScalarT, typename IdxT>
+    class CircuitComponent : public Model::Evaluator<ScalarT, IdxT>
+    {
+    public:
+      using RealT      = typename Model::Evaluator<ScalarT, IdxT>::RealT;
+      using CsrMatrixT = typename Model::Evaluator<ScalarT, IdxT>::CsrMatrixT;
+      using VectorT    = typename Model::Evaluator<ScalarT, IdxT>::VectorT;
+
+      CircuitComponent() = default;
+
+    protected:
+      /**
+       * @brief Constructs a copy of a circuit component.
+       *
+       * Copies the component metadata, local vector data, connection-node mapping,
+       * and COO Jacobian storage. Dynamically allocated component-owned data is
+       * deep-copied so that the new component does not share ownership of this
+       * storage with @p other.
+       *
+       * Pointers to state, state-derivative, and residual storage supplied by a
+       * parent system are copied as-is. Consequently, the copied component initially
+       * references the same parent-system storage as @p other. The pointer arrays
+       * used for external variables are independently allocated, but their entries
+       * point to the same external state, state-derivative, and residual storage as
+       * the original component.
+       *
+       * Local vectors, including the state, state derivative, residual, tolerances,
+       * quadrature data, adjoint data, and parameter vectors, retain the values of
+       * the original component.
+       *
+       * @param other Component to copy.
+       *
+       * @note If the copied component is subsequently attached to a different parent
+       *       system, its state, state-derivative, and residual pointers must be
+       *       reassigned to the storage provided by that system before evaluation.
+       */
+      CircuitComponent(const CircuitComponent& other)
+        : n_extern_(other.n_extern_),
+          n_intern_(other.n_intern_),
+          extern_indices_(other.extern_indices_),
+          size_(other.size_),
+          nnz_(other.nnz_),
+          size_quad_(other.size_quad_),
+          size_opt_(other.size_opt_),
+          current_jac_size_(other.current_jac_size_),
+          y_int_(other.y_int_),
+          yp_int_(other.yp_int_),
+          f_int_(other.f_int_),
+          tag_(other.tag_),
+          time_(other.time_),
+          alpha_(other.alpha_),
+          max_steps_(other.max_steps_),
+          idc_(other.idc_),
+          allocated_(other.allocated_)
       {
-        const IdxT source_size = source.getSize();
 
-        if (source_size == 0)
+        auto copyVector = [](VectorT& destination, const VectorT& source)
         {
-          return;
+          const IdxT source_size = source.getSize();
+
+          if (source_size == 0)
+          {
+            return;
+          }
+
+          destination.resize(source_size);
+          destination.copyFromExternal(source);
+        };
+
+        /*
+         * Deep-copy the local-to-global connection mapping.
+         */
+        if (other.connection_nodes_)
+        {
+          connection_nodes_ = std::make_unique<IdxT[]>(static_cast<size_t>(size_));
+
+          for (size_t i = 0; i < static_cast<size_t>(size_); ++i)
+          {
+            connection_nodes_[i] = other.connection_nodes_[i];
+          }
         }
 
-        destination.resize(source_size);
-        destination.copyFromExternal(source);
-      };
+        /*
+         * Deep-copy the COO Jacobian row indices.
+         */
+        if (other.jacobian_coo_rows_)
+        {
+          jacobian_coo_rows_ = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
 
-      /*
-       * Deep-copy the local-to-global connection mapping.
-       */
-      if (other.connection_nodes_)
-      {
-        connection_nodes_ = std::make_unique<IdxT[]>(static_cast<size_t>(size_));
+          for (size_t i = 0; i < static_cast<size_t>(nnz_); ++i)
+          {
+            jacobian_coo_rows_[i] = other.jacobian_coo_rows_[i];
+          }
+        }
 
-        for (size_t i = 0; i < static_cast<size_t>(size_); ++i)
+        /*
+         * Deep-copy the COO Jacobian column indices.
+         */
+        if (other.jacobian_coo_cols_)
         {
-          connection_nodes_[i] = other.connection_nodes_[i];
+          jacobian_coo_cols_ = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
+
+          for (size_t i = 0; i < static_cast<size_t>(nnz_); ++i)
+          {
+            jacobian_coo_cols_[i] = other.jacobian_coo_cols_[i];
+          }
         }
-      }
 
-      /*
-       * Deep-copy the COO Jacobian row indices.
-       */
-      if (other.jacobian_coo_rows_)
-      {
-        jacobian_coo_rows_ = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
+        /*
+         * Deep-copy the COO Jacobian values.
+         */
+        if (other.jacobian_coo_values_)
+        {
+          jacobian_coo_values_ = std::make_unique<RealT[]>(static_cast<size_t>(nnz_));
+
+          for (size_t i = 0; i < static_cast<size_t>(nnz_); ++i)
+          {
+            jacobian_coo_values_[i] = other.jacobian_coo_values_[i];
+          }
+        }
 
-        for (size_t i = 0; i < static_cast<size_t>(nnz_); ++i)
+        if (size_ > 0)
         {
-          jacobian_coo_rows_[i] = other.jacobian_coo_rows_[i];
+          y_ext_  = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
+          yp_ext_ = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
+          f_ext_  = std::make_unique<ScalarT*[]>(static_cast<size_t>(size_));
+
+          for (size_t i = 0; i < static_cast<size_t>(size_); ++i)
+          {
+            y_ext_[i]  = other.y_ext_[i];
+            yp_ext_[i] = other.yp_ext_[i];
+            f_ext_[i]  = other.f_ext_[i];
+          }
         }
+
+        // State, state derivative, residual, and absolute tolerance.
+        copyVector(y_, other.y_);
+        copyVector(yp_, other.yp_);
+        copyVector(f_, other.f_);
+        copyVector(abs_tol_, other.abs_tol_);
+        copyVector(g_, other.g_);
+        copyVector(yB_, other.yB_);
+        copyVector(ypB_, other.ypB_);
+        copyVector(fB_, other.fB_);
+        copyVector(gB_, other.gB_);
+        copyVector(param_, other.param_);
+        copyVector(param_up_, other.param_up_);
+        copyVector(param_lo_, other.param_lo_);
       }
 
-      /*
-       * Deep-copy the COO Jacobian column indices.
+    public:
+      /**
+       * @brief Create an independent copy of this component.
+       *
+       * The clone preserves the component's model configuration, parameters,
+       * topology, and structural data, but does not preserve bindings to
+       * system-owned state or residual storage.
+       *
+       * @note By default, the cloned component's state, state-derivative, and
+       * residual pointers are not set. The user is responsible for setting these
+       * pointers to the appropriate storage before evaluating the residual.
        */
-      if (other.jacobian_coo_cols_)
+      virtual CircuitComponent<ScalarT, IdxT>* clone() const
       {
-        jacobian_coo_cols_ = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
-
-        for (size_t i = 0; i < static_cast<size_t>(nnz_); ++i)
-        {
-          jacobian_coo_cols_[i] = other.jacobian_coo_cols_[i];
-        }
+        throw std::runtime_error("clone() is not supported for this component.");
       }
 
-      /*
-       * Deep-copy the COO Jacobian values.
+      /**
+       * @brief Indicates whether this component supports cloning.
+       *
+       * Derived components that implement clone() should override this method
+       * and return true.
+       *
+       * @return true if the component can be cloned, false otherwise.
        */
-      if (other.jacobian_coo_values_)
+      virtual bool isCloneable() const
       {
-        jacobian_coo_values_ = std::make_unique<RealT[]>(static_cast<size_t>(nnz_));
+        return false;
+      }
 
-        for (size_t i = 0; i < static_cast<size_t>(nnz_); ++i)
-        {
-          jacobian_coo_values_[i] = other.jacobian_coo_values_[i];
-        }
+      /**
+       * @note Cannot be marked final, since it is overriden to recurse in the system model.
+       */
+      void updateTime(RealT t, RealT a) override
+      {
+        this->time_  = t;
+        this->alpha_ = a;
       }
 
-      if (size_ > 0)
+      bool hasJacobian() override
       {
-        y_ext_  = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
-        yp_ext_ = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
-        f_ext_  = std::make_unique<ScalarT*[]>(static_cast<size_t>(size_));
+        return true;
+      }
 
-        for (size_t i = 0; i < static_cast<size_t>(size_); ++i)
-        {
-          y_ext_[i]  = other.y_ext_[i];
-          yp_ext_[i] = other.yp_ext_[i];
-          f_ext_[i]  = other.f_ext_[i];
-        }
+      size_t getExternSize()
+      {
+        return n_extern_;
       }
 
-      // State, state derivative, residual, and absolute tolerance.
-      copyVector(y_, other.y_);
-      copyVector(yp_, other.yp_);
-      copyVector(f_, other.f_);
-      copyVector(abs_tol_, other.abs_tol_);
-      copyVector(g_, other.g_);
-      copyVector(yB_, other.yB_);
-      copyVector(ypB_, other.ypB_);
-      copyVector(fB_, other.fB_);
-      copyVector(gB_, other.gB_);
-      copyVector(param_, other.param_);
-      copyVector(param_up_, other.param_up_);
-      copyVector(param_lo_, other.param_lo_);
-    }
-
-  public:
-    /**
-     * @brief Create an independent copy of this component.
-     *
-     * The clone preserves the component's model configuration, parameters,
-     * topology, and structural data, but does not preserve bindings to
-     * system-owned state or residual storage.
-     *
-     * @note By default, the cloned component's state, state-derivative, and
-     * residual pointers are not set. The user is responsible for setting these
-     * pointers to the appropriate storage before evaluating the residual.
-     */
-    virtual CircuitComponent<ScalarT, IdxT>* clone() const
-    {
-      throw std::runtime_error("clone() is not supported for this component.");
-    }
+      size_t getInternalSize()
+      {
+        return this->n_intern_;
+      }
 
-    /**
-     * @brief Indicates whether this component supports cloning.
-     *
-     * Derived components that implement clone() should override this method
-     * and return true.
-     *
-     * @return true if the component can be cloned, false otherwise.
-     */
-    virtual bool isCloneable() const
-    {
-      return false;
-    }
+      std::set<IdxT> getExternIndices()
+      {
+        return this->extern_indices_;
+      }
 
-    /**
-     * @note Cannot be marked final, since it is overriden to recurse in the system model.
-     */
-    void updateTime(RealT t, RealT a) override
-    {
-      this->time_  = t;
-      this->alpha_ = a;
-    }
+      /**
+       * @brief Create the mappings from local to global indices for an internal variable.
+       * Used for constructing system Jacobians \see connection_nodes_.
+       *
+       * @param local_index The index of the local variable
+       * @param global_index The index of the corresponding system variable.
+       *
+       * @pre `local_index` *must* be the index of an internal variable. Using this method for
+       * an external variable will not properly setup the data pointers for that variable.
+       */
+      int setInternalConnectionNodes(size_t local_index, IdxT global_index)
+      {
+        assert(!extern_indices_.contains(static_cast<IdxT>(local_index)));
+        setConnectionNodes(local_index, global_index);
+        return 0;
+      }
 
-    bool hasJacobian() override
-    {
-      return true;
-    }
+      /**
+       * @brief Create the mappings from local to global indices for an external variable.
+       * External variables need extra information than internal variables - their data
+       * pointers \ref y_ext_, \ref yp_ext_, and \ref f_ext_.
+       *
+       * @param local_index The index of the local variable
+       * @param connection The necessary connection information for the variable
+       *
+       * @pre `local_index` *must* be the index of an external variable. As of now, using this method
+       * to set information for a local variable will silently discard the unnecessary information, but
+       * this may change in the future.
+       */
+      int setExternalConnectionNodes(size_t local_index, ExternalConnection<ScalarT, IdxT> connection)
+      {
+        assert(extern_indices_.contains(local_index));
+        y_ext_[local_index]  = connection.y_;
+        yp_ext_[local_index] = connection.yp_;
+        f_ext_[local_index]  = connection.f_;
+        setConnectionNodes(local_index, connection.idx_);
+        return 0;
+      }
 
-    size_t getExternSize()
-    {
-      return n_extern_;
-    }
+      /**
+       * @brief Update the connection index for a variable.
+       *
+       * Sets only the connection index without modifying the variable's
+       * internal/external classification or its associated data pointers.
+       *
+       * @param local_index Index of the local variable.
+       * @param connection_index New connection index for the variable.
+       *
+       * @return int 0 if successful.
+       */
+      int setConnectionNodes(size_t local_index, IdxT connection_index)
+      {
+        connection_nodes_[local_index] = connection_index;
+        return 0;
+      }
 
-    size_t getInternalSize()
-    {
-      return this->n_intern_;
-    }
+      /**
+       * @brief Given the location of value in the local vector map to global index
+       *
+       * f(local_index) = global_index
+       *
+       * @param local_index index of local value in vector
+       * @return size_t Index of the same value in the global vector
+       */
+      IdxT getNodeConnection(size_t local_index) const
+      {
+        return connection_nodes_[local_index];
+      }
 
-    std::set<IdxT> getExternIndices()
-    {
-      return this->extern_indices_;
-    }
+      int initialize() override
+      {
+        y_.setDataUpdated();
+        yp_.setDataUpdated();
 
-    /**
-     * @brief Create the mappings from local to global indices for an internal variable.
-     * Used for constructing system Jacobians \see connection_nodes_.
-     *
-     * @param local_index The index of the local variable
-     * @param global_index The index of the corresponding system variable.
-     *
-     * @pre `local_index` *must* be the index of an internal variable. Using this method for
-     * an external variable will not properly setup the data pointers for that variable.
-     */
-    int setInternalConnectionNodes(size_t local_index, IdxT global_index)
-    {
-      assert(!extern_indices_.contains(static_cast<IdxT>(local_index)));
-      setConnectionNodes(local_index, global_index);
-      return 0;
-    }
-
-    /**
-     * @brief Create the mappings from local to global indices for an external variable.
-     * External variables need extra information than internal variables - their data
-     * pointers \ref y_ext_, \ref yp_ext_, and \ref f_ext_.
-     *
-     * @param local_index The index of the local variable
-     * @param connection The necessary connection information for the variable
-     *
-     * @pre `local_index` *must* be the index of an external variable. As of now, using this method
-     * to set information for a local variable will silently discard the unnecessary information, but
-     * this may change in the future.
-     */
-    int setExternalConnectionNodes(size_t local_index, ExternalConnection<ScalarT, IdxT> connection)
-    {
-      assert(extern_indices_.contains(local_index));
-      y_ext_[local_index]  = connection.y_;
-      yp_ext_[local_index] = connection.yp_;
-      f_ext_[local_index]  = connection.f_;
-      setConnectionNodes(local_index, connection.idx_);
-      return 0;
-    }
-
-    /**
-     * @brief Update the connection index for a variable.
-     *
-     * Sets only the connection index without modifying the variable's
-     * internal/external classification or its associated data pointers.
-     *
-     * @param local_index Index of the local variable.
-     * @param connection_index New connection index for the variable.
-     *
-     * @return int 0 if successful.
-     */
-    int setConnectionNodes(size_t local_index, IdxT connection_index)
-    {
-      connection_nodes_[local_index] = connection_index;
-      return 0;
-    }
+        return 0;
+      }
 
-    /**
-     * @brief Given the location of value in the local vector map to global index
-     *
-     * f(local_index) = global_index
-     *
-     * @param local_index index of local value in vector
-     * @return size_t Index of the same value in the global vector
-     */
-    IdxT getNodeConnection(size_t local_index) const
-    {
-      return connection_nodes_[local_index];
-    }
+      /**
+       * @brief Allocates all of the internal buffers for the component.
+       * If a components needs a more specialized allocation (such as by having additional internal buffers),
+       * it should override this function and then call it in the body to ensure it stays up-to-date with
+       * new implementations.
+       *
+       * @pre \ref nnz_ and \ref size_ must be set. Typically these are set by the child object in its constructor.
+       *
+       * @return An error code, or 0 if success
+       */
+      int allocate() override
+      {
+        jacobian_coo_rows_   = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
+        jacobian_coo_cols_   = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
+        jacobian_coo_values_ = std::make_unique<RealT[]>(static_cast<size_t>(nnz_));
 
-    int initialize() override
-    {
-      y_.setDataUpdated();
-      yp_.setDataUpdated();
+        y_ext_  = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
+        yp_ext_ = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
+        f_ext_  = std::make_unique<ScalarT*[]>(static_cast<size_t>(size_));
 
-      return 0;
-    }
+        connection_nodes_ = std::make_unique<IdxT[]>(static_cast<size_t>(size_));
 
-    /**
-     * @brief Allocates all of the internal buffers for the component.
-     * If a components needs a more specialized allocation (such as by having additional internal buffers),
-     * it should override this function and then call it in the body to ensure it stays up-to-date with
-     * new implementations.
-     *
-     * @pre \ref nnz_ and \ref size_ must be set. Typically these are set by the child object in its constructor.
-     *
-     * @return An error code, or 0 if success
-     */
-    int allocate() override
-    {
-      jacobian_coo_rows_   = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
-      jacobian_coo_cols_   = std::make_unique<IdxT[]>(static_cast<size_t>(nnz_));
-      jacobian_coo_values_ = std::make_unique<RealT[]>(static_cast<size_t>(nnz_));
+        tag_.resize(static_cast<size_t>(size_));
 
-      y_ext_  = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
-      yp_ext_ = std::make_unique<const ScalarT*[]>(static_cast<size_t>(size_));
-      f_ext_  = std::make_unique<ScalarT*[]>(static_cast<size_t>(size_));
+        if (!allocated_)
+        {
+          allocateVectors(size_);
+        }
 
-      connection_nodes_ = std::make_unique<IdxT[]>(static_cast<size_t>(size_));
+        allocated_ = true;
+        return 0;
+      }
 
-      tag_.resize(static_cast<size_t>(size_));
+      IdxT* jacobianCooRows()
+      {
+        return jacobian_coo_rows_.get();
+      }
 
-      if (!allocated_)
+      const IdxT* jacobianCooRows() const
       {
-        allocateVectors(size_);
+        return jacobian_coo_rows_.get();
       }
 
-      allocated_ = true;
-      return 0;
-    }
+      IdxT* jacobianCooCols()
+      {
+        return jacobian_coo_cols_.get();
+      }
 
-    IdxT* jacobianCooRows()
-    {
-      return jacobian_coo_rows_.get();
-    }
+      const IdxT* jacobianCooCols() const
+      {
+        return jacobian_coo_cols_.get();
+      }
 
-    const IdxT* jacobianCooRows() const
-    {
-      return jacobian_coo_rows_.get();
-    }
+      RealT* jacobianCooValues()
+      {
+        return jacobian_coo_values_.get();
+      }
 
-    IdxT* jacobianCooCols()
-    {
-      return jacobian_coo_cols_.get();
-    }
+      const RealT* jacobianCooValues() const
+      {
+        return jacobian_coo_values_.get();
+      }
 
-    const IdxT* jacobianCooCols() const
-    {
-      return jacobian_coo_cols_.get();
-    }
+      /**
+       * @brief Evaluating the residual of a CircuitComponent should be done by evaluating the
+       * internal residuals and external residuals. CircuitComponents should overload those
+       * functions for their residuals (and the system will call those function instead of this one),
+       * so there is no reason to overload this functionality.
+       *
+       * @return An error code, or 0 is successful.
+       */
+      int evaluateResidual() final
+      {
+        if (int err_code = evaluateInternalResidual())
+          return err_code;
 
-    RealT* jacobianCooValues()
-    {
-      return jacobian_coo_values_.get();
-    }
+        f_.setDataUpdated();
 
-    const RealT* jacobianCooValues() const
-    {
-      return jacobian_coo_values_.get();
-    }
-
-    /**
-     * @brief Evaluating the residual of a CircuitComponent should be done by evaluating the
-     * internal residuals and external residuals. CircuitComponents should overload those
-     * functions for their residuals (and the system will call those function instead of this one),
-     * so there is no reason to overload this functionality.
-     *
-     * @return An error code, or 0 is successful.
-     */
-    int evaluateResidual() final
-    {
-      if (int err_code = evaluateInternalResidual())
-        return err_code;
+        return evaluateExternalResidual();
+      }
 
-      f_.setDataUpdated();
+      /**
+       * @brief Evaluate all residuals for the component's internal variables,
+       * writing them through `f_int_`.
+       *
+       * @return An error code, or 0 if successful.
+       */
+      virtual int evaluateInternalResidual() = 0;
 
-      return evaluateExternalResidual();
-    }
+      /**
+       * @brief Evaluate all residual contributions for the component's external variables,
+       * accumulating them through `f_ext_`.
+       *
+       * @return An error code, or 0 if successful.
+       */
+      virtual int evaluateExternalResidual() = 0;
 
-    /**
-     * @brief Evaluate all residuals for the component's internal variables,
-     * writing them through `f_int_`.
-     *
-     * @return An error code, or 0 if successful.
-     */
-    virtual int evaluateInternalResidual() = 0;
+      void setInternalPointer(const ScalarT* internals)
+      {
+        y_int_ = internals;
+      }
 
-    /**
-     * @brief Evaluate all residual contributions for the component's external variables,
-     * accumulating them through `f_ext_`.
-     *
-     * @return An error code, or 0 if successful.
-     */
-    virtual int evaluateExternalResidual() = 0;
+      void setInternalDerivativePointer(const ScalarT* internals_p)
+      {
+        yp_int_ = internals_p;
+      }
 
-    void setInternalPointer(const ScalarT* internals)
-    {
-      y_int_ = internals;
-    }
+      void setInternalResidualPointer(ScalarT* internal_res)
+      {
+        f_int_ = internal_res;
+      }
 
-    void setInternalDerivativePointer(const ScalarT* internals_p)
-    {
-      yp_int_ = internals_p;
-    }
+    protected:
+      /**
+       * @brief Reset the Jacobian so it can be constructed. Helper method for \ref setJacValues().
+       * Sets \ref current_jac_size_ to 0 so that future calls to `setJacValues()` will override previous values.
+       *
+       */
+      void zeroJacMatrix()
+      {
+        current_jac_size_ = 0;
+      }
 
-    void setInternalResidualPointer(ScalarT* internal_res)
-    {
-      f_int_ = internal_res;
-    }
+      /**
+       * @brief Helper method for adding values to the Jacobian. Copies the rows, cols, and vals buffers and appends
+       * them to the end of the corresponding Jacobian buffers. Uses \ref current_jac_size_ to tell where the end of
+       * the Jacobian currently is.
+       *
+       * @pre `rows`, `cols`, `vals` must all be the same size
+       * @pre \ref allocate() must be called first.
+       * @pre Must call \ref zeroJacMatrix() before starting construction of a new Jacobian
+       * @pre The must be enough room for the values in the allocated buffers, i.e. `current_jac_size_ + rows.size() <= nnz_`
+       */
+      void setJacValues(const std::vector<IdxT>& rows, const std::vector<IdxT>& cols, const std::vector<RealT>& vals)
+      {
+        assert(rows.size() == cols.size());
+        assert(rows.size() == vals.size());
+        assert(current_jac_size_ + rows.size() <= static_cast<size_t>(nnz_));
 
-  protected:
-    /**
-     * @brief Reset the Jacobian so it can be constructed. Helper method for \ref setJacValues().
-     * Sets \ref current_jac_size_ to 0 so that future calls to `setJacValues()` will override previous values.
-     *
-     */
-    void zeroJacMatrix()
-    {
-      current_jac_size_ = 0;
-    }
+        for (size_t i = 0; i < rows.size(); i++)
+        {
+          jacobian_coo_rows_[current_jac_size_]   = rows[i];
+          jacobian_coo_cols_[current_jac_size_]   = cols[i];
+          jacobian_coo_values_[current_jac_size_] = vals[i];
 
-    /**
-     * @brief Helper method for adding values to the Jacobian. Copies the rows, cols, and vals buffers and appends
-     * them to the end of the corresponding Jacobian buffers. Uses \ref current_jac_size_ to tell where the end of
-     * the Jacobian currently is.
-     *
-     * @pre `rows`, `cols`, `vals` must all be the same size
-     * @pre \ref allocate() must be called first.
-     * @pre Must call \ref zeroJacMatrix() before starting construction of a new Jacobian
-     * @pre The must be enough room for the values in the allocated buffers, i.e. `current_jac_size_ + rows.size() <= nnz_`
-     */
-    void setJacValues(const std::vector<IdxT>& rows, const std::vector<IdxT>& cols, const std::vector<RealT>& vals)
-    {
-      assert(rows.size() == cols.size());
-      assert(rows.size() == vals.size());
-      assert(current_jac_size_ + rows.size() <= static_cast<size_t>(nnz_));
+          current_jac_size_++;
+        }
+      }
 
-      for (size_t i = 0; i < rows.size(); i++)
+    public:
+      IdxT size() final
       {
-        jacobian_coo_rows_[current_jac_size_]   = rows[i];
-        jacobian_coo_cols_[current_jac_size_]   = cols[i];
-        jacobian_coo_values_[current_jac_size_] = vals[i];
-
-        current_jac_size_++;
+        return size_;
       }
-    }
-
-  public:
-    IdxT size() final
-    {
-      return size_;
-    }
-
-    IdxT size() const
-    {
-      return size_;
-    }
 
-    IdxT nnz() final
-    {
-      return nnz_;
-    }
+      IdxT size() const
+      {
+        return size_;
+      }
 
-    IdxT nnz() const
-    {
-      return nnz_;
-    }
+      IdxT nnz() final
+      {
+        return nnz_;
+      }
 
-    IdxT sizeQuadrature() final
-    {
-      return size_quad_;
-    }
+      IdxT nnz() const
+      {
+        return nnz_;
+      }
 
-    IdxT sizeQuadrature() const
-    {
-      return size_quad_;
-    }
+      IdxT sizeQuadrature() final
+      {
+        return size_quad_;
+      }
 
-    IdxT sizeParams() final
-    {
-      return size_opt_;
-    }
+      IdxT sizeQuadrature() const
+      {
+        return size_quad_;
+      }
 
-    IdxT sizeParams() const
-    {
-      return size_opt_;
-    }
+      IdxT sizeParams() final
+      {
+        return size_opt_;
+      }
 
-    VectorT& y() final
-    {
-      return y_;
-    }
+      IdxT sizeParams() const
+      {
+        return size_opt_;
+      }
 
-    const VectorT& y() const final
-    {
-      return y_;
-    }
+      VectorT& y() final
+      {
+        return y_;
+      }
 
-    VectorT& yp() final
-    {
-      return yp_;
-    }
+      const VectorT& y() const final
+      {
+        return y_;
+      }
 
-    const VectorT& yp() const final
-    {
-      return yp_;
-    }
+      VectorT& yp() final
+      {
+        return yp_;
+      }
 
-    std::vector<bool>& tag() final
-    {
-      return tag_;
-    }
+      const VectorT& yp() const final
+      {
+        return yp_;
+      }
 
-    const std::vector<bool>& tag() const final
-    {
-      return tag_;
-    }
+      std::vector<bool>& tag() final
+      {
+        return tag_;
+      }
 
-    VectorT& absoluteTolerance() final
-    {
-      return abs_tol_;
-    }
+      const std::vector<bool>& tag() const final
+      {
+        return tag_;
+      }
 
-    const VectorT& absoluteTolerance() const final
-    {
-      return abs_tol_;
-    }
+      VectorT& absoluteTolerance() final
+      {
+        return abs_tol_;
+      }
 
-    VectorT& yB() final
-    {
-      return yB_;
-    }
+      const VectorT& absoluteTolerance() const final
+      {
+        return abs_tol_;
+      }
 
-    const VectorT& yB() const final
-    {
-      return yB_;
-    }
+      VectorT& yB() final
+      {
+        return yB_;
+      }
 
-    VectorT& ypB() final
-    {
-      return ypB_;
-    }
+      const VectorT& yB() const final
+      {
+        return yB_;
+      }
 
-    const VectorT& ypB() const final
-    {
-      return ypB_;
-    }
+      VectorT& ypB() final
+      {
+        return ypB_;
+      }
 
-    VectorT& param() final
-    {
-      return param_;
-    }
+      const VectorT& ypB() const final
+      {
+        return ypB_;
+      }
 
-    const VectorT& param() const final
-    {
-      return param_;
-    }
+      VectorT& param() final
+      {
+        return param_;
+      }
 
-    VectorT& param_up() final
-    {
-      return param_up_;
-    }
+      const VectorT& param() const final
+      {
+        return param_;
+      }
 
-    const VectorT& param_up() const final
-    {
-      return param_up_;
-    }
+      VectorT& param_up() final
+      {
+        return param_up_;
+      }
 
-    VectorT& param_lo() final
-    {
-      return param_lo_;
-    }
+      const VectorT& param_up() const final
+      {
+        return param_up_;
+      }
 
-    const VectorT& param_lo() const final
-    {
-      return param_lo_;
-    }
+      VectorT& param_lo() final
+      {
+        return param_lo_;
+      }
 
-    VectorT& getResidual() final
-    {
-      return f_;
-    }
+      const VectorT& param_lo() const final
+      {
+        return param_lo_;
+      }
 
-    const VectorT& getResidual() const final
-    {
-      return f_;
-    }
+      VectorT& getResidual() final
+      {
+        return f_;
+      }
 
-    VectorT& getIntegrand() final
-    {
-      return g_;
-    }
+      const VectorT& getResidual() const final
+      {
+        return f_;
+      }
 
-    const VectorT& getIntegrand() const final
-    {
-      return g_;
-    }
+      VectorT& getIntegrand() final
+      {
+        return g_;
+      }
 
-    VectorT& getAdjointResidual() final
-    {
-      return fB_;
-    }
+      const VectorT& getIntegrand() const final
+      {
+        return g_;
+      }
 
-    const VectorT& getAdjointResidual() const final
-    {
-      return fB_;
-    }
+      VectorT& getAdjointResidual() final
+      {
+        return fB_;
+      }
 
-    VectorT& getAdjointIntegrand() final
-    {
-      return gB_;
-    }
+      const VectorT& getAdjointResidual() const final
+      {
+        return fB_;
+      }
 
-    const VectorT& getAdjointIntegrand() const final
-    {
-      return gB_;
-    }
+      VectorT& getAdjointIntegrand() final
+      {
+        return gB_;
+      }
 
-    //@todo Fix ID naming
-    IdxT getIDcomponent() const
-    {
-      return idc_;
-    }
+      const VectorT& getAdjointIntegrand() const final
+      {
+        return gB_;
+      }
 
-    /**
-     * @brief Check whether the component has already been allocated.
-     *
-     * @return true if allocate() has previously completed, false otherwise.
-     */
-    bool isAllocated() const
-    {
-      return allocated_;
-    }
+      //@todo Fix ID naming
+      IdxT getIDcomponent() const
+      {
+        return idc_;
+      }
 
-  protected:
-    /**
-     * @brief Allocate state and residual storage owned by this component.
-     *
-     * Most components do not need state and residual storages. The most notable exception
-     * is currently the system, so a separate flag is provided for the system.
-     * Systems still can't directly access \ref y_, \ref yp_, and \ref f_, so they need
-     * their corresponding \ref y_int_, \ref yp_int_, and \ref f_int_ set, since there isn't
-     * another system above them to set it.
-     *
-     * @todo This is a weird exception specifically for systems - and in a hierarchical setting
-     * will only be needed by the *topmost* system - subsystems shouldn't allocate and should have their
-     * internal pointers set by the system above them. Ideally we can remove this exception by having
-     * the integrator allocate these buffers instead of the system and set the internal pointers for the
-     * topmost system.
-     */
-    void allocateVectors(IdxT n, bool system = false)
-    {
-      abs_tol_.resize(n);
+      /**
+       * @brief Check whether the component has already been allocated.
+       *
+       * @return true if allocate() has previously completed, false otherwise.
+       */
+      bool isAllocated() const
+      {
+        return allocated_;
+      }
 
-      if (system)
+    protected:
+      /**
+       * @brief Allocate state and residual storage owned by this component.
+       *
+       * Most components do not need state and residual storages. The most notable exception
+       * is currently the system, so a separate flag is provided for the system.
+       * Systems still can't directly access \ref y_, \ref yp_, and \ref f_, so they need
+       * their corresponding \ref y_int_, \ref yp_int_, and \ref f_int_ set, since there isn't
+       * another system above them to set it.
+       *
+       * @todo This is a weird exception specifically for systems - and in a hierarchical setting
+       * will only be needed by the *topmost* system - subsystems shouldn't allocate and should have their
+       * internal pointers set by the system above them. Ideally we can remove this exception by having
+       * the integrator allocate these buffers instead of the system and set the internal pointers for the
+       * topmost system.
+       */
+      void allocateVectors(IdxT n, bool system = false)
       {
-        y_.resize(n);
-        yp_.resize(n);
-        f_.resize(n);
+        abs_tol_.resize(n);
 
-        y_int_  = y_.getData();
-        yp_int_ = yp_.getData();
-        f_int_  = f_.getData();
-      }
-    }
+        if (system)
+        {
+          y_.resize(n);
+          yp_.resize(n);
+          f_.resize(n);
 
-    /// Number of external variables in this component - ones which are referenced but not owned by this component.
-    size_t                  n_extern_;
-    /// Number of internal variables in this component - ones which are only referenced by this component.
-    size_t                  n_intern_;
-    /**
-     * @brief A set of variable indices which correspond to the external variables. Variables indices not in this set are internal.
-     *
-     * @invariant Must have a size of \ref n_extern_. Each element must be in the range [0, \ref size_ - 1]. Not currently verified anywhere.
-     */
-    std::set<IdxT>          extern_indices_;
-    /**
-     * @brief A map from local variable indices to system (global) variable indices. Used for Jacobian construction in
-     * \ref PowerElectronicsModel::evaluateJacobian().
-     * @note If a variable does not map to a corresponding variable in the system (such as with reference nodes), a special
-     * sentinel value of \ref INVALID_INDEX is used. During Jacobian construction, such rows and columns will be pruned.
-     */
-    std::unique_ptr<IdxT[]> connection_nodes_;
-
-    /// The number of variables in this component. Should be equal to \ref n_extern_ plus \ref n_intern_. \see size()
-    IdxT size_{0};
-    /// The number of nonzero elements in this component's Jacobian. \see nnz()
-    IdxT nnz_{0};
-    IdxT size_quad_{0};
-    IdxT size_opt_{0};
-
-    // COO Jacobian buffers
-    std::unique_ptr<IdxT[]>  jacobian_coo_rows_;
-    std::unique_ptr<IdxT[]>  jacobian_coo_cols_;
-    std::unique_ptr<RealT[]> jacobian_coo_values_;
-
-    /// The number of non-zero elements currently inserted into the Jacobian. See \ref setJacValues()
-    size_t current_jac_size_{0};
-
-    /// @brief A pointer to the internal variables of this component.
-    const ScalarT* y_int_;
-    /// @brief A pointer to the internal derivatives of this component.
-    const ScalarT* yp_int_;
-    /// @brief A pointer to the internal residuals of this component
-    ScalarT*       f_int_;
-
-    /**
-     * An array of (input) pointers to state values for external variables.
-     * \note The size of this array is equal to \ref size_, allowing you to index it with the index
-     * of the variable in question (i.e. consisten with \ref extern_indices_). Therefore, accessing
-     * and dereferencing the pointer in an internal variable index is undefined behavior.
-     * \see setExternalConnectionNodes()
-     */
-    std::unique_ptr<const ScalarT*[]> y_ext_;
-    /**
-     * An array of (input) pointers to derivative values for external variables.
-     * \note The size of this array is equal to \ref size_, allowing you to index it with the index
-     * of the variable in question (i.e. consisten with \ref extern_indices_). Therefore, accessing
-     * and dereferencing the pointer in an internal variable index is undefined behavior.
-     * \see setExternalConnectionNodes()
-     */
-    std::unique_ptr<const ScalarT*[]> yp_ext_;
-    /**
-     * An array of (output) pointers to residuals for external variables.
-     * \note The size of this array is equal to \ref size_, allowing you to index it with the index
-     * of the variable in question (i.e. consisten with \ref extern_indices_). Therefore, accessing
-     * and dereferencing the pointer in an internal variable index is undefined behavior.
-     * \see setExternalConnectionNodes()
-     */
-    std::unique_ptr<ScalarT*[]>       f_ext_;
+          y_int_  = y_.getData();
+          yp_int_ = yp_.getData();
+          f_int_  = f_.getData();
+        }
+      }
 
-    std::vector<bool> tag_;
-    VectorT           abs_tol_;
+      /// Number of external variables in this component - ones which are referenced but not owned by this component.
+      size_t                  n_extern_;
+      /// Number of internal variables in this component - ones which are only referenced by this component.
+      size_t                  n_intern_;
+      /**
+       * @brief A set of variable indices which correspond to the external variables. Variables indices not in this set are internal.
+       *
+       * @invariant Must have a size of \ref n_extern_. Each element must be in the range [0, \ref size_ - 1]. Not currently verified anywhere.
+       */
+      std::set<IdxT>          extern_indices_;
+      /**
+       * @brief A map from local variable indices to system (global) variable indices. Used for Jacobian construction in
+       * \ref PowerElectronicsModel::evaluateJacobian().
+       * @note If a variable does not map to a corresponding variable in the system (such as with reference nodes), a special
+       * sentinel value of \ref INVALID_INDEX is used. During Jacobian construction, such rows and columns will be pruned.
+       */
+      std::unique_ptr<IdxT[]> connection_nodes_;
+
+      /// The number of variables in this component. Should be equal to \ref n_extern_ plus \ref n_intern_. \see size()
+      IdxT size_{0};
+      /// The number of nonzero elements in this component's Jacobian. \see nnz()
+      IdxT nnz_{0};
+      IdxT size_quad_{0};
+      IdxT size_opt_{0};
+
+      // COO Jacobian buffers
+      std::unique_ptr<IdxT[]>  jacobian_coo_rows_;
+      std::unique_ptr<IdxT[]>  jacobian_coo_cols_;
+      std::unique_ptr<RealT[]> jacobian_coo_values_;
+
+      /// The number of non-zero elements currently inserted into the Jacobian. See \ref setJacValues()
+      size_t current_jac_size_{0};
+
+      /// @brief A pointer to the internal variables of this component.
+      const ScalarT* y_int_;
+      /// @brief A pointer to the internal derivatives of this component.
+      const ScalarT* yp_int_;
+      /// @brief A pointer to the internal residuals of this component
+      ScalarT*       f_int_;
+
+      /**
+       * An array of (input) pointers to state values for external variables.
+       * \note The size of this array is equal to \ref size_, allowing you to index it with the index
+       * of the variable in question (i.e. consisten with \ref extern_indices_). Therefore, accessing
+       * and dereferencing the pointer in an internal variable index is undefined behavior.
+       * \see setExternalConnectionNodes()
+       */
+      std::unique_ptr<const ScalarT*[]> y_ext_;
+      /**
+       * An array of (input) pointers to derivative values for external variables.
+       * \note The size of this array is equal to \ref size_, allowing you to index it with the index
+       * of the variable in question (i.e. consisten with \ref extern_indices_). Therefore, accessing
+       * and dereferencing the pointer in an internal variable index is undefined behavior.
+       * \see setExternalConnectionNodes()
+       */
+      std::unique_ptr<const ScalarT*[]> yp_ext_;
+      /**
+       * An array of (output) pointers to residuals for external variables.
+       * \note The size of this array is equal to \ref size_, allowing you to index it with the index
+       * of the variable in question (i.e. consisten with \ref extern_indices_). Therefore, accessing
+       * and dereferencing the pointer in an internal variable index is undefined behavior.
+       * \see setExternalConnectionNodes()
+       */
+      std::unique_ptr<ScalarT*[]>       f_ext_;
 
-    VectorT g_;
+      std::vector<bool> tag_;
+      VectorT           abs_tol_;
 
-    VectorT yB_;
-    VectorT ypB_;
-    VectorT fB_;
-    VectorT gB_;
+      VectorT g_;
 
-    VectorT param_;
-    VectorT param_up_;
-    VectorT param_lo_;
+      VectorT yB_;
+      VectorT ypB_;
+      VectorT fB_;
+      VectorT gB_;
 
-    RealT time_;
-    RealT alpha_;
+      VectorT param_;
+      VectorT param_up_;
+      VectorT param_lo_;
 
-    IdxT max_steps_;
+      RealT time_;
+      RealT alpha_;
 
-    IdxT idc_;
+      IdxT max_steps_;
 
-    bool allocated_{false};
+      IdxT idc_;
 
-  private:
-    /**
-     * The internal buffer for state for the component. For most components, it will be empty and shouldn't be accessed.
-     * Instead use \ref y_int_ for an internal variable or \ref y_ext_ for an external variable, respectively.
-     * For components which want an internal buffer (such as a system), make sure that \ref y_int_ points here.
-     * \see allocateVectors()
-     */
-    VectorT y_;
-    /**
-     * The internal buffer for derivatives for the component. For most components, it will be empty and shouldn't be accessed.
-     * Instead use \ref yp_int_ for an internal variable or \ref yp_ext_ for an external variable, respectively.
-     * For components which want an internal buffer (such as a system), make sure that \ref yp_int_ points here.
-     * \see allocateVectors()
-     */
-    VectorT yp_;
-    /**
-     * The internal buffer for state for the component. For most components, it will be empty and shouldn't be accessed.
-     * Instead use \ref f_int_ for an internal variable or \ref f_ext_ for an external variable, respectively.
-     * For components which want an internal buffer (such as a system), make sure that \ref f_int_ points here.
-     * \see allocateVectors()
-     */
-    VectorT f_;
-  };
+      bool allocated_{false};
 
+    private:
+      /**
+       * The internal buffer for state for the component. For most components, it will be empty and shouldn't be accessed.
+       * Instead use \ref y_int_ for an internal variable or \ref y_ext_ for an external variable, respectively.
+       * For components which want an internal buffer (such as a system), make sure that \ref y_int_ points here.
+       * \see allocateVectors()
+       */
+      VectorT y_;
+      /**
+       * The internal buffer for derivatives for the component. For most components, it will be empty and shouldn't be accessed.
+       * Instead use \ref yp_int_ for an internal variable or \ref yp_ext_ for an external variable, respectively.
+       * For components which want an internal buffer (such as a system), make sure that \ref yp_int_ points here.
+       * \see allocateVectors()
+       */
+      VectorT yp_;
+      /**
+       * The internal buffer for state for the component. For most components, it will be empty and shouldn't be accessed.
+       * Instead use \ref f_int_ for an internal variable or \ref f_ext_ for an external variable, respectively.
+       * For components which want an internal buffer (such as a system), make sure that \ref f_int_ points here.
+       * \see allocateVectors()
+       */
+      VectorT f_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/CircuitGraph.hpp b/GridKit/Model/PowerElectronics/CircuitGraph.hpp
deleted file mode 100644
index 5a57104fb..000000000
--- a/GridKit/Model/PowerElectronics/CircuitGraph.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-
-
-#include <cmath>
-#include <iostream>
-#include <map>
-#include <unordered_set>
-#include <vector>
-
-/**
- * @brief A very basic hypergraph setup for circuit representation.
- * This forms the hypergraph as a bipartite graph. Doesn't allow
- * removing. Can only grab sets of connections to nodes
- *
- * @todo should replace with something better and more efficent.
- * Should replace with a libraries setup instead. This would allow
- * fast and easy partitioning of circuits
- *
- * @todo This is to replace inserting vector size for allocating PowerElectronicsModel
- *
- * @todo should replace N and E with Node and Component classes respectively.
- *
- * @note Tested but currently not used in the rest of the code.
- *
- * @tparam IdxT
- * @tparam Label
- */
-template <typename N, typename E>
-class CircuitGraph
-{
-private:
-  std::set<N>              hypernodes;
-  std::set<E>              hyperedges;
-  std::map<E, std::set<N>> edgestonodes;
-
-public:
-  CircuitGraph();
-  ~CircuitGraph();
-  bool        addHyperEdge(E he);
-  bool        addHyperNode(N hn);
-  bool        addConnection(N hn, E he);
-  std::set<N> getHyperEdgeConnections(E he);
-  size_t      amountHyperNodes();
-  size_t      amountHyperEdges();
-  void        printBiPartiteGraph(bool verbose = false);
-};
-
-template <typename N, typename E>
-CircuitGraph<N, E>::CircuitGraph()
-{
-}
-
-template <typename N, typename E>
-CircuitGraph<N, E>::~CircuitGraph()
-{
-}
-
-template <typename N, typename E>
-bool CircuitGraph<N, E>::addHyperNode(N hn)
-{
-  return this->hypernodes.insert(hn).second;
-}
-
-template <typename N, typename E>
-bool CircuitGraph<N, E>::addHyperEdge(E he)
-{
-  return this->hyperedges.insert(he).second;
-}
-
-template <typename N, typename E>
-bool CircuitGraph<N, E>::addConnection(N hn, E he)
-{
-  if (this->hyperedges.count(he) == 0 || this->hypernodes.count(hn) == 0)
-  {
-    return false;
-  }
-  return this->edgestonodes[he].insert(hn).second;
-}
-
-template <typename N, typename E>
-std::set<N> CircuitGraph<N, E>::getHyperEdgeConnections(E he)
-{
-  return this->edgestonodes[he];
-}
-
-template <typename N, typename E>
-size_t CircuitGraph<N, E>::amountHyperNodes()
-{
-  return this->hypernodes.size();
-}
-
-template <typename N, typename E>
-size_t CircuitGraph<N, E>::amountHyperEdges()
-{
-  return this->hyperedges.size();
-}
-
-/**
- * @brief Print the bipartite graph
- *
- * @todo need to add verbose printing for connections display
- *
- * @tparam IdxT
- * @param[in] verbose if true will print connections,
- * otherwise just the number of nodes and edges
- */
-
-template <typename N, typename E>
-void CircuitGraph<N, E>::printBiPartiteGraph([[maybe_unused]] bool verbose)
-{
-
-  std::cout << "Amount of HyperNodes: " << this->amountHyperNodes() << std::endl;
-  std::cout << "Amount of HyperEdges: " << this->amountHyperEdges() << std::endl;
-  std::cout << "Connections per Edge:" << std::endl;
-  for (auto i : this->edgestonodes)
-  {
-    std::cout << i.first << " : {";
-    for (auto j : i.second)
-    {
-      std::cout << j << ", ";
-    }
-    std::cout << "}\n";
-  }
-}
diff --git a/GridKit/Model/PowerElectronics/CircuitNode.hpp b/GridKit/Model/PowerElectronics/CircuitNode.hpp
index 7b1e52bf8..176e5f7d7 100644
--- a/GridKit/Model/PowerElectronics/CircuitNode.hpp
+++ b/GridKit/Model/PowerElectronics/CircuitNode.hpp
@@ -9,374 +9,377 @@
 
 namespace GridKit
 {
-  /**
-   * @brief Circuit node representing a connection point.
-   */
-  template <typename ScalarT, typename IdxT>
-  class CircuitNode : public Model::Evaluator<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT   = typename Model::Evaluator<ScalarT, IdxT>::RealT;
-    using VectorT = typename Model::Evaluator<ScalarT, IdxT>::VectorT;
-
-  public:
-    CircuitNode()
-    {
-      size_ = 1;
-    }
-
-    CircuitNode(ScalarT v0)
-      : V0_(v0)
+    /**
+     * @brief Circuit node representing a connection point.
+     */
+    template <typename ScalarT, typename IdxT>
+    class CircuitNode : public Model::Evaluator<ScalarT, IdxT>
     {
-      size_ = 1;
-    }
+      using RealT   = typename Model::Evaluator<ScalarT, IdxT>::RealT;
+      using VectorT = typename Model::Evaluator<ScalarT, IdxT>::VectorT;
 
-    ~CircuitNode() = default;
+    public:
+      CircuitNode()
+      {
+        size_ = 1;
+      }
 
-    int setNodeID(IdxT id)
-    {
-      id_ = id;
-      return 0;
-    }
+      CircuitNode(ScalarT v0)
+        : V0_(v0)
+      {
+        size_ = 1;
+      }
 
-    IdxT nodeID() const
-    {
-      return id_;
-    }
+      ~CircuitNode() = default;
 
-    // Voltage accessor
-    ScalarT& V()
-    {
-      return y_.getData()[0];
-    }
+      int setNodeID(IdxT id)
+      {
+        id_ = id;
+        return 0;
+      }
 
-    const ScalarT& V() const
-    {
-      return y_.getData()[0];
-    }
+      IdxT nodeID() const
+      {
+        return id_;
+      }
 
-    // KCL residual accessor
-    ScalarT& I()
-    {
-      return f_.getData()[0];
-    }
+      // Voltage accessor
+      ScalarT& V()
+      {
+        return y_.getData()[0];
+      }
 
-    const ScalarT& I() const
-    {
-      return f_.getData()[0];
-    }
+      const ScalarT& V() const
+      {
+        return y_.getData()[0];
+      }
 
-    // Allocate storage for a single-node voltage and KCL residual
-    int allocate()
-    {
-      size_t size = static_cast<size_t>(size_);
+      // KCL residual accessor
+      ScalarT& I()
+      {
+        return f_.getData()[0];
+      }
 
-      if (!allocated_)
+      const ScalarT& I() const
       {
-        allocateVectors(size_);
+        return f_.getData()[0];
       }
 
-      tag_.resize(size);
+      // Allocate storage for a single-node voltage and KCL residual
+      int allocate()
+      {
+        size_t size = static_cast<size_t>(size_);
 
-      variable_indices_[0] = 0;
-      residual_indices_[0] = 0;
+        if (!allocated_)
+        {
+          allocateVectors(size_);
+        }
 
-      allocated_ = true;
-      return 0;
-    }
+        tag_.resize(size);
 
-    /**
-     * @brief Initialize node variables
-     */
-    int initialize()
-    {
-      auto* y  = y_.getData();
-      auto* yp = yp_.getData();
+        variable_indices_[0] = 0;
+        residual_indices_[0] = 0;
 
-      y[0]  = V0_;
-      yp[0] = 0.0;
+        allocated_ = true;
+        return 0;
+      }
 
-      y_.setDataUpdated();
-      yp_.setDataUpdated();
+      /**
+       * @brief Initialize node variables
+       */
+      int initialize()
+      {
+        auto* y  = y_.getData();
+        auto* yp = yp_.getData();
 
-      return 0;
-    }
+        y[0]  = V0_;
+        yp[0] = 0.0;
 
-    /**
-     * @brief Node variables are algebraic.
-     */
-    int tagDifferentiable()
-    {
-      tag_[0] = false;
+        y_.setDataUpdated();
+        yp_.setDataUpdated();
 
-      return 0;
-    }
+        return 0;
+      }
 
-    /**
-     * @brief Compute the absolute tolerance for each variable in the model
-     *
-     * @param rel_tol The relative tolerance which can be used to pick the
-     *        absolute tolerance.
-     * @tparam ScalarT Scalar data type
-     * @tparam IdxT Index data type
-     * @return int 0 if successful, non-zero otherwise.
-     *
-     * This represents a "noise" level close to zero for which pure relative
-     * error cannot be used.
-     */
-    int setAbsoluteTolerance(RealT rel_tol)
-    {
-      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-      return 0;
-    }
+      /**
+       * @brief Node variables are algebraic.
+       */
+      int tagDifferentiable()
+      {
+        tag_[0] = false;
 
-    /**
-     * @brief Node does not compute residuals, so here we just reset residual values.
-     *
-     * @warning This implementation assumes node residuals are always evaluated
-     * _before_ component model residuals.
-     *
-     */
-    int evaluateResidual()
-    {
-      auto* f = f_.getData();
+        return 0;
+      }
 
-      f[0] = 0.0;
+      /**
+       * @brief Compute the absolute tolerance for each variable in the model
+       *
+       * @param rel_tol The relative tolerance which can be used to pick the
+       *        absolute tolerance.
+       * @tparam ScalarT Scalar data type
+       * @tparam IdxT Index data type
+       * @return int 0 if successful, non-zero otherwise.
+       *
+       * This represents a "noise" level close to zero for which pure relative
+       * error cannot be used.
+       */
+      int setAbsoluteTolerance(RealT rel_tol)
+      {
+        abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+        return 0;
+      }
 
-      f_.setDataUpdated();
+      /**
+       * @brief Node does not compute residuals, so here we just reset residual values.
+       *
+       * @warning This implementation assumes node residuals are always evaluated
+       * _before_ component model residuals.
+       *
+       */
+      int evaluateResidual()
+      {
+        auto* f = f_.getData();
 
-      return 0;
-    }
+        f[0] = 0.0;
 
-    bool hasJacobian() final
-    {
-      return false;
-    }
+        f_.setDataUpdated();
 
-    /**
-     * @brief There is no Jacobian for node variables
-     */
-    int evaluateJacobian()
-    {
-      return 0;
-    }
+        return 0;
+      }
 
-    int evaluateIntegrand()
-    {
-      return 0;
-    }
+      bool hasJacobian() final
+      {
+        return false;
+      }
 
-    int initializeAdjoint()
-    {
-      return 0;
-    }
+      /**
+       * @brief There is no Jacobian for node variables
+       */
+      int evaluateJacobian()
+      {
+        return 0;
+      }
 
-    int evaluateAdjointResidual()
-    {
-      return 0;
-    }
+      int evaluateIntegrand()
+      {
+        return 0;
+      }
 
-    int evaluateAdjointIntegrand()
-    {
-      return 0;
-    }
+      int initializeAdjoint()
+      {
+        return 0;
+      }
 
-  private:
-    IdxT    id_{static_cast<IdxT>(-1)};
-    IdxT    size_{0};
-    IdxT    nnz_{0};
-    IdxT    size_quad_{0};
-    IdxT    size_opt_{0};
-    ScalarT V0_{0.0};
+      int evaluateAdjointResidual()
+      {
+        return 0;
+      }
 
-    std::map<IdxT, IdxT> variable_indices_;
-    std::map<IdxT, IdxT> residual_indices_;
+      int evaluateAdjointIntegrand()
+      {
+        return 0;
+      }
 
-    VectorT           y_;
-    VectorT           yp_;
-    std::vector<bool> tag_;
-    VectorT           abs_tol_;
-    VectorT           f_;
+    private:
+      IdxT    id_{static_cast<IdxT>(-1)};
+      IdxT    size_{0};
+      IdxT    nnz_{0};
+      IdxT    size_quad_{0};
+      IdxT    size_opt_{0};
+      ScalarT V0_{0.0};
 
-    VectorT g_{};
-    VectorT param_{};
-    VectorT param_up_{};
-    VectorT param_lo_{};
+      std::map<IdxT, IdxT> variable_indices_;
+      std::map<IdxT, IdxT> residual_indices_;
 
-    VectorT yB_{};
-    VectorT ypB_{};
-    VectorT fB_{};
-    VectorT gB_{};
+      VectorT           y_;
+      VectorT           yp_;
+      std::vector<bool> tag_;
+      VectorT           abs_tol_;
+      VectorT           f_;
 
-    RealT time_{0};
-    RealT alpha_{0};
+      VectorT g_{};
+      VectorT param_{};
+      VectorT param_up_{};
+      VectorT param_lo_{};
 
-    IdxT max_steps_{0};
+      VectorT yB_{};
+      VectorT ypB_{};
+      VectorT fB_{};
+      VectorT gB_{};
 
-    bool allocated_{false};
+      RealT time_{0};
+      RealT alpha_{0};
 
-  public:
-    IdxT size() final
-    {
-      return size_;
-    }
+      IdxT max_steps_{0};
 
-    IdxT nnz() final
-    {
-      return nnz_;
-    }
+      bool allocated_{false};
 
-    IdxT sizeQuadrature() final
-    {
-      return size_quad_;
-    }
+    public:
+      IdxT size() final
+      {
+        return size_;
+      }
 
-    IdxT sizeParams() final
-    {
-      return size_opt_;
-    }
+      IdxT nnz() final
+      {
+        return nnz_;
+      }
 
-    void updateTime(RealT /* t */, RealT /* a */) final
-    {
-      // No time to update in node models
-    }
+      IdxT sizeQuadrature() final
+      {
+        return size_quad_;
+      }
 
-    VectorT& y() final
-    {
-      return y_;
-    }
+      IdxT sizeParams() final
+      {
+        return size_opt_;
+      }
 
-    const VectorT& y() const final
-    {
-      return y_;
-    }
+      void updateTime(RealT /* t */, RealT /* a */) final
+      {
+        // No time to update in node models
+      }
 
-    VectorT& yp() final
-    {
-      return yp_;
-    }
+      VectorT& y() final
+      {
+        return y_;
+      }
 
-    const VectorT& yp() const final
-    {
-      return yp_;
-    }
+      const VectorT& y() const final
+      {
+        return y_;
+      }
 
-    std::vector<bool>& tag() final
-    {
-      return tag_;
-    }
+      VectorT& yp() final
+      {
+        return yp_;
+      }
 
-    const std::vector<bool>& tag() const final
-    {
-      return tag_;
-    }
+      const VectorT& yp() const final
+      {
+        return yp_;
+      }
 
-    VectorT& absoluteTolerance() final
-    {
-      return abs_tol_;
-    }
+      std::vector<bool>& tag() final
+      {
+        return tag_;
+      }
 
-    const VectorT& absoluteTolerance() const final
-    {
-      return abs_tol_;
-    }
+      const std::vector<bool>& tag() const final
+      {
+        return tag_;
+      }
 
-    VectorT& yB() final
-    {
-      return yB_;
-    }
+      VectorT& absoluteTolerance() final
+      {
+        return abs_tol_;
+      }
 
-    const VectorT& yB() const final
-    {
-      return yB_;
-    }
+      const VectorT& absoluteTolerance() const final
+      {
+        return abs_tol_;
+      }
 
-    VectorT& ypB() final
-    {
-      return ypB_;
-    }
+      VectorT& yB() final
+      {
+        return yB_;
+      }
 
-    const VectorT& ypB() const final
-    {
-      return ypB_;
-    }
+      const VectorT& yB() const final
+      {
+        return yB_;
+      }
 
-    VectorT& param() final
-    {
-      return param_;
-    }
+      VectorT& ypB() final
+      {
+        return ypB_;
+      }
 
-    const VectorT& param() const final
-    {
-      return param_;
-    }
+      const VectorT& ypB() const final
+      {
+        return ypB_;
+      }
 
-    VectorT& param_up() final
-    {
-      return param_up_;
-    }
+      VectorT& param() final
+      {
+        return param_;
+      }
 
-    const VectorT& param_up() const final
-    {
-      return param_up_;
-    }
+      const VectorT& param() const final
+      {
+        return param_;
+      }
 
-    VectorT& param_lo() final
-    {
-      return param_lo_;
-    }
+      VectorT& param_up() final
+      {
+        return param_up_;
+      }
 
-    const VectorT& param_lo() const final
-    {
-      return param_lo_;
-    }
+      const VectorT& param_up() const final
+      {
+        return param_up_;
+      }
 
-    VectorT& getResidual() final
-    {
-      return f_;
-    }
+      VectorT& param_lo() final
+      {
+        return param_lo_;
+      }
 
-    const VectorT& getResidual() const final
-    {
-      return f_;
-    }
+      const VectorT& param_lo() const final
+      {
+        return param_lo_;
+      }
 
-    VectorT& getIntegrand() final
-    {
-      return g_;
-    }
+      VectorT& getResidual() final
+      {
+        return f_;
+      }
 
-    const VectorT& getIntegrand() const final
-    {
-      return g_;
-    }
+      const VectorT& getResidual() const final
+      {
+        return f_;
+      }
 
-    VectorT& getAdjointResidual() final
-    {
-      return fB_;
-    }
+      VectorT& getIntegrand() final
+      {
+        return g_;
+      }
 
-    const VectorT& getAdjointResidual() const final
-    {
-      return fB_;
-    }
+      const VectorT& getIntegrand() const final
+      {
+        return g_;
+      }
 
-    VectorT& getAdjointIntegrand() final
-    {
-      return gB_;
-    }
+      VectorT& getAdjointResidual() final
+      {
+        return fB_;
+      }
 
-    const VectorT& getAdjointIntegrand() const final
-    {
-      return gB_;
-    }
+      const VectorT& getAdjointResidual() const final
+      {
+        return fB_;
+      }
 
-  private:
-    void allocateVectors(IdxT n)
-    {
-      y_.resize(n);
-      yp_.resize(n);
-      f_.resize(n);
-      abs_tol_.resize(n);
-    }
-  };
+      VectorT& getAdjointIntegrand() final
+      {
+        return gB_;
+      }
+
+      const VectorT& getAdjointIntegrand() const final
+      {
+        return gB_;
+      }
+
+    private:
+      void allocateVectors(IdxT n)
+      {
+        y_.resize(n);
+        yp_.resize(n);
+        f_.resize(n);
+        abs_tol_.resize(n);
+      }
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp
index db4a280a5..5b0c6967b 100644
--- a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp
+++ b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp
@@ -1,5 +1,4 @@
 
-
 #include "DistributedGenerator.hpp"
 
 #include <cmath>
@@ -7,431 +6,433 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a Distributed Generator
-   * @todo Maybe have parameters be templated in. Variables cannot be changed
-   * and are unlikely to. Allows for compile time optimizations
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   */
-  template <class ScalarT, typename IdxT>
-  DistributedGenerator<ScalarT, IdxT>::DistributedGenerator(IdxT                                        id,
-                                                            DistributedGeneratorParameters<RealT, IdxT> parm,
-                                                            bool                                        reference_frame,
-                                                            NodeT*                                      node_ref,
-                                                            NodeT*                                      node_bus)
-    : wb_(parm.wb_),
-      wc_(parm.wc_),
-      mp_(parm.mp_),
-      Vn_(parm.Vn_),
-      nq_(parm.nq_),
-      F_(parm.F_),
-      Kiv_(parm.Kiv_),
-      Kpv_(parm.Kpv_),
-      Kic_(parm.Kic_),
-      Kpc_(parm.Kpc_),
-      Cf_(parm.Cf_),
-      rLf_(parm.rLf_),
-      Lf_(parm.Lf_),
-      rLc_(parm.rLc_),
-      Lc_(parm.Lc_),
-      refframe_(reference_frame),
-      node_ref_(node_ref),
-      node_bus_(node_bus)
-  {
-    assert(refframe_ || node_ref_->size() == 1);
-    assert(node_bus_->size() == 2);
-    // internals [Pi, Qi, phi_di, phi_qi, gamma_di, gamma_qi, il_di, il_qi, vo_di, vo_qi, io_di, io_qi, \delta_i]
-    // externals [\omega_ref, vba_out, vbb_out]
-    size_     = refframe_ ? 15 : 16;
-    n_intern_ = refframe_ ? 12 : 13;
-    n_extern_ = 3;
-    idc_      = id;
-    nnz_      = refframe_ ? 73 : 78;
-
-    extern_indices_ = {0, 1, 2};
-  }
-
-  template <class ScalarT, typename IdxT>
-  DistributedGenerator<ScalarT, IdxT>::~DistributedGenerator()
+  namespace PowerElectronics
   {
-  }
+    /*!
+     * @brief Constructor for a Distributed Generator
+     * @todo Maybe have parameters be templated in. Variables cannot be changed
+     * and are unlikely to. Allows for compile time optimizations
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     */
+    template <class ScalarT, typename IdxT>
+    DistributedGenerator<ScalarT, IdxT>::DistributedGenerator(IdxT                                        id,
+                                                              DistributedGeneratorParameters<RealT, IdxT> parm,
+                                                              bool                                        reference_frame,
+                                                              NodeT*                                      node_ref,
+                                                              NodeT*                                      node_bus)
+      : wb_(parm.wb_),
+        wc_(parm.wc_),
+        mp_(parm.mp_),
+        Vn_(parm.Vn_),
+        nq_(parm.nq_),
+        F_(parm.F_),
+        Kiv_(parm.Kiv_),
+        Kpv_(parm.Kpv_),
+        Kic_(parm.Kic_),
+        Kpc_(parm.Kpc_),
+        Cf_(parm.Cf_),
+        rLf_(parm.rLf_),
+        Lf_(parm.Lf_),
+        rLc_(parm.rLc_),
+        Lc_(parm.Lc_),
+        refframe_(reference_frame),
+        node_ref_(node_ref),
+        node_bus_(node_bus)
+    {
+      assert(refframe_ || node_ref_->size() == 1);
+      assert(node_bus_->size() == 2);
+      // internals [Pi, Qi, phi_di, phi_qi, gamma_di, gamma_qi, il_di, il_qi, vo_di, vo_qi, io_di, io_qi, \delta_i]
+      // externals [\omega_ref, vba_out, vbb_out]
+      size_     = refframe_ ? 15 : 16;
+      n_intern_ = refframe_ ? 12 : 13;
+      n_extern_ = 3;
+      idc_      = id;
+      nnz_      = refframe_ ? 73 : 78;
+
+      extern_indices_ = {0, 1, 2};
+    }
 
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Contributes to the resisdual of the Distributed Generator
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    ScalarT omega = wb_ - mp_ * y_int_[0];
-    ScalarT delta = refframe_ ? ScalarT(0.0) : y_int_[12];
+    template <class ScalarT, typename IdxT>
+    DistributedGenerator<ScalarT, IdxT>::~DistributedGenerator()
+    {
+    }
 
-    // Take incoming voltages to current rotator reference frame
-    ScalarT vbd_in = std::cos(delta) * *y_ext_[1] + std::sin(delta) * *y_ext_[2];
-    ScalarT vbq_in = -std::sin(delta) * *y_ext_[1] + std::cos(delta) * *y_ext_[2];
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
 
-    // ### Internal Componenets ##
-    // P and Q equations
-    f_int_[0] = -yp_int_[0] + wc_ * (y_int_[8] * y_int_[10] + y_int_[9] * y_int_[11] - y_int_[0]);
-    f_int_[1] = -yp_int_[1] + wc_ * (-y_int_[8] * y_int_[11] + y_int_[9] * y_int_[10] - y_int_[1]);
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
 
-    // Voltage control
-    ScalarT vod_star = Vn_ - nq_ * y_int_[1];
-    ScalarT voq_star = static_cast<ScalarT>(0.0);
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
 
-    f_int_[2] = -yp_int_[2] + vod_star - y_int_[8];
-    f_int_[3] = -yp_int_[3] + voq_star - y_int_[9];
+    /**
+     * @brief Contributes to the resisdual of the Distributed Generator
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      ScalarT omega = wb_ - mp_ * y_int_[0];
+      ScalarT delta = refframe_ ? ScalarT(0.0) : y_int_[12];
 
-    ScalarT ild_star = F_ * y_int_[10] - wb_ * Cf_ * y_int_[9] + Kpv_ * (vod_star - y_int_[8]) + Kiv_ * y_int_[2];
-    ScalarT ilq_star = F_ * y_int_[11] + wb_ * Cf_ * y_int_[8] + Kpv_ * (voq_star - y_int_[9]) + Kiv_ * y_int_[3];
+      // Take incoming voltages to current rotator reference frame
+      ScalarT vbd_in = std::cos(delta) * *y_ext_[1] + std::sin(delta) * *y_ext_[2];
+      ScalarT vbq_in = -std::sin(delta) * *y_ext_[1] + std::cos(delta) * *y_ext_[2];
 
-    // Current control
-    f_int_[4] = -yp_int_[4] + ild_star - y_int_[6];
-    f_int_[5] = -yp_int_[5] + ilq_star - y_int_[7];
+      // ### Internal Componenets ##
+      // P and Q equations
+      f_int_[0] = -yp_int_[0] + wc_ * (y_int_[8] * y_int_[10] + y_int_[9] * y_int_[11] - y_int_[0]);
+      f_int_[1] = -yp_int_[1] + wc_ * (-y_int_[8] * y_int_[11] + y_int_[9] * y_int_[10] - y_int_[1]);
 
-    ScalarT vid_star = -wb_ * Lf_ * y_int_[7] + Kpc_ * (ild_star - y_int_[6]) + Kic_ * y_int_[4];
-    ScalarT viq_star = wb_ * Lf_ * y_int_[6] + Kpc_ * (ilq_star - y_int_[7]) + Kic_ * y_int_[5];
+      // Voltage control
+      ScalarT vod_star = Vn_ - nq_ * y_int_[1];
+      ScalarT voq_star = static_cast<ScalarT>(0.0);
 
-    // Output LC Filter
-    f_int_[6] = -yp_int_[6] - (rLf_ / Lf_) * y_int_[6] + omega * y_int_[7] + (vid_star - y_int_[8]) / Lf_;
-    f_int_[7] = -yp_int_[7] - (rLf_ / Lf_) * y_int_[7] - omega * y_int_[6] + (viq_star - y_int_[9]) / Lf_;
+      f_int_[2] = -yp_int_[2] + vod_star - y_int_[8];
+      f_int_[3] = -yp_int_[3] + voq_star - y_int_[9];
 
-    f_int_[8] = -yp_int_[8] + omega * y_int_[9] + (y_int_[6] - y_int_[10]) / Cf_;
-    f_int_[9] = -yp_int_[9] - omega * y_int_[8] + (y_int_[7] - y_int_[11]) / Cf_;
+      ScalarT ild_star = F_ * y_int_[10] - wb_ * Cf_ * y_int_[9] + Kpv_ * (vod_star - y_int_[8]) + Kiv_ * y_int_[2];
+      ScalarT ilq_star = F_ * y_int_[11] + wb_ * Cf_ * y_int_[8] + Kpv_ * (voq_star - y_int_[9]) + Kiv_ * y_int_[3];
 
-    // Output Connector
-    f_int_[10] = -yp_int_[10] - (rLc_ / Lc_) * y_int_[10] + omega * y_int_[11] + (y_int_[8] - vbd_in) / Lc_;
-    f_int_[11] = -yp_int_[11] - (rLc_ / Lc_) * y_int_[11] - omega * y_int_[10] + (y_int_[9] - vbq_in) / Lc_;
+      // Current control
+      f_int_[4] = -yp_int_[4] + ild_star - y_int_[6];
+      f_int_[5] = -yp_int_[5] + ilq_star - y_int_[7];
 
-    // Rotor difference angle
-    if (!refframe_)
-    {
-      f_int_[12] = -yp_int_[12] + omega - *y_ext_[0];
-    }
+      ScalarT vid_star = -wb_ * Lf_ * y_int_[7] + Kpc_ * (ild_star - y_int_[6]) + Kic_ * y_int_[4];
+      ScalarT viq_star = wb_ * Lf_ * y_int_[6] + Kpc_ * (ilq_star - y_int_[7]) + Kic_ * y_int_[5];
 
-    return 0;
-  }
+      // Output LC Filter
+      f_int_[6] = -yp_int_[6] - (rLf_ / Lf_) * y_int_[6] + omega * y_int_[7] + (vid_star - y_int_[8]) / Lf_;
+      f_int_[7] = -yp_int_[7] - (rLf_ / Lf_) * y_int_[7] - omega * y_int_[6] + (viq_star - y_int_[9]) / Lf_;
 
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    ScalarT omega = wb_ - mp_ * y_int_[0];
-    ScalarT delta = refframe_ ? ScalarT(0.0) : y_int_[12];
+      f_int_[8] = -yp_int_[8] + omega * y_int_[9] + (y_int_[6] - y_int_[10]) / Cf_;
+      f_int_[9] = -yp_int_[9] - omega * y_int_[8] + (y_int_[7] - y_int_[11]) / Cf_;
+
+      // Output Connector
+      f_int_[10] = -yp_int_[10] - (rLc_ / Lc_) * y_int_[10] + omega * y_int_[11] + (y_int_[8] - vbd_in) / Lc_;
+      f_int_[11] = -yp_int_[11] - (rLc_ / Lc_) * y_int_[11] - omega * y_int_[10] + (y_int_[9] - vbq_in) / Lc_;
 
-    // ref common ref motor angle
-    if (refframe_)
+      // Rotor difference angle
+      if (!refframe_)
+      {
+        f_int_[12] = -yp_int_[12] + omega - *y_ext_[0];
+      }
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::evaluateExternalResidual()
     {
-      *f_ext_[0] += omega - *y_ext_[0];
+      ScalarT omega = wb_ - mp_ * y_int_[0];
+      ScalarT delta = refframe_ ? ScalarT(0.0) : y_int_[12];
+
+      // ref common ref motor angle
+      if (refframe_)
+      {
+        *f_ext_[0] += omega - *y_ext_[0];
+      }
+
+      // output
+      // current transformed to common frame
+      *f_ext_[1] += std::cos(delta) * y_int_[10] - std::sin(delta) * y_int_[11];
+      *f_ext_[2] += std::sin(delta) * y_int_[10] + std::cos(delta) * y_int_[11];
+      return 0;
     }
 
-    // output
-    // current transformed to common frame
-    *f_ext_[1] += std::cos(delta) * y_int_[10] - std::sin(delta) * y_int_[11];
-    *f_ext_[2] += std::sin(delta) * y_int_[10] + std::cos(delta) * y_int_[11];
-    return 0;
-  }
-
-  /**
-   * @brief Compute the jacobian of the DistributedGenerator for iteration. dF/dy - \alpha dF/dy'
-   *
-   * The matrix dF/dy should be
-   *
-  [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
-  [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
-  [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
-  [-1,           0,           0,                             0,     -mp,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
-  [ 0,           0,           0,                             0,     -wc,                0,            0,            0,      0,      0,                 0,                 0,            wc*x15,            wc*x16,     wc*x13,     wc*x14]
-  [ 0,           0,           0,                             0,       0,              -wc,            0,            0,      0,      0,                 0,                 0,           -wc*x16,            wc*x15,     wc*x14,    -wc*x13]
-  [ 0,           0,           0,                             0,       0,              -nq,            0,            0,      0,      0,                 0,                 0,                -1,                 0,          0,          0]
-  [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                -1,          0,          0]
-  [ 0,           0,           0,                             0,       0,          -Kpv*nq,          Kiv,            0,      0,      0,                -1,                 0,              -Kpv,            -Cf*wb,          F,          0]
-  [ 0,           0,           0,                             0,       0,                0,            0,          Kiv,      0,      0,                 0,                -1,             Cf*wb,              -Kpv,          0,          F]
-  [ 0,           0,           0,                             0, -mp*x12, -(Kpc*Kpv*nq)/Lf, (Kiv*Kpc)/Lf,            0, Kic/Lf,      0, - Kpc/Lf - rLf/Lf,            -mp*x5, -(Kpc*Kpv + 1)/Lf,   -(Cf*Kpc*wb)/Lf, (F*Kpc)/Lf,          0]
-  [ 0,           0,           0,                             0,  mp*x11,                0,            0, (Kiv*Kpc)/Lf,      0, Kic/Lf,             mp*x5, - Kpc/Lf - rLf/Lf,    (Cf*Kpc*wb)/Lf, -(Kpc*Kpv + 1)/Lf,          0, (F*Kpc)/Lf]
-  [ 0,           0,           0,                             0, -mp*x14,                0,            0,            0,      0,      0,              1/Cf,                 0,                 0,        wb - mp*x5,      -1/Cf,          0]
-  [ 0,           0,           0,                             0,  mp*x13,                0,            0,            0,      0,      0,                 0,              1/Cf,        mp*x5 - wb,                 0,          0,      -1/Cf]
-  [ 0, -cos(x4)/Lc, -sin(x4)/Lc, -(x3*cos(x4) - x2*sin(x4))/Lc, -mp*x16,                0,            0,            0,      0,      0,                 0,                 0,              1/Lc,                 0,    -rLc/Lc, wb - mp*x5]
-  [ 0,  sin(x4)/Lc, -cos(x4)/Lc,  (x2*cos(x4) + x3*sin(x4))/Lc,  mp*x15,                0,            0,            0,      0,      0,                 0,                 0,                 0,              1/Lc, mp*x5 - wb,    -rLc/Lc]
-   * 'Generated from MATLAB symbolic'
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
+    /**
+     * @brief Compute the jacobian of the DistributedGenerator for iteration. dF/dy - \alpha dF/dy'
+     *
+     * The matrix dF/dy should be
+     *
+    [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
+    [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
+    [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
+    [-1,           0,           0,                             0,     -mp,                0,            0,            0,      0,      0,                 0,                 0,                 0,                 0,          0,          0]
+    [ 0,           0,           0,                             0,     -wc,                0,            0,            0,      0,      0,                 0,                 0,            wc*x15,            wc*x16,     wc*x13,     wc*x14]
+    [ 0,           0,           0,                             0,       0,              -wc,            0,            0,      0,      0,                 0,                 0,           -wc*x16,            wc*x15,     wc*x14,    -wc*x13]
+    [ 0,           0,           0,                             0,       0,              -nq,            0,            0,      0,      0,                 0,                 0,                -1,                 0,          0,          0]
+    [ 0,           0,           0,                             0,       0,                0,            0,            0,      0,      0,                 0,                 0,                 0,                -1,          0,          0]
+    [ 0,           0,           0,                             0,       0,          -Kpv*nq,          Kiv,            0,      0,      0,                -1,                 0,              -Kpv,            -Cf*wb,          F,          0]
+    [ 0,           0,           0,                             0,       0,                0,            0,          Kiv,      0,      0,                 0,                -1,             Cf*wb,              -Kpv,          0,          F]
+    [ 0,           0,           0,                             0, -mp*x12, -(Kpc*Kpv*nq)/Lf, (Kiv*Kpc)/Lf,            0, Kic/Lf,      0, - Kpc/Lf - rLf/Lf,            -mp*x5, -(Kpc*Kpv + 1)/Lf,   -(Cf*Kpc*wb)/Lf, (F*Kpc)/Lf,          0]
+    [ 0,           0,           0,                             0,  mp*x11,                0,            0, (Kiv*Kpc)/Lf,      0, Kic/Lf,             mp*x5, - Kpc/Lf - rLf/Lf,    (Cf*Kpc*wb)/Lf, -(Kpc*Kpv + 1)/Lf,          0, (F*Kpc)/Lf]
+    [ 0,           0,           0,                             0, -mp*x14,                0,            0,            0,      0,      0,              1/Cf,                 0,                 0,        wb - mp*x5,      -1/Cf,          0]
+    [ 0,           0,           0,                             0,  mp*x13,                0,            0,            0,      0,      0,                 0,              1/Cf,        mp*x5 - wb,                 0,          0,      -1/Cf]
+    [ 0, -cos(x4)/Lc, -sin(x4)/Lc, -(x3*cos(x4) - x2*sin(x4))/Lc, -mp*x16,                0,            0,            0,      0,      0,                 0,                 0,              1/Lc,                 0,    -rLc/Lc, wb - mp*x5]
+    [ 0,  sin(x4)/Lc, -cos(x4)/Lc,  (x2*cos(x4) + x3*sin(x4))/Lc,  mp*x15,                0,            0,            0,      0,      0,                 0,                 0,                 0,              1/Lc, mp*x5 - wb,    -rLc/Lc]
+     * 'Generated from MATLAB symbolic'
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      std::vector<IdxT>  ctemp{};
+      std::vector<IdxT>  rtemp{};
+      std::vector<RealT> valtemp{};
+
+      RealT delta = refframe_ ? RealT(0.0) : static_cast<RealT>(y_int_[12]);
+
+      // r = 0
+      if (refframe_)
+      {
+        rtemp.assign(2, 0);
+        ctemp   = {0, 3};
+        valtemp = {-1.0, -mp_};
+        this->setJacValues(rtemp, ctemp, valtemp);
+      }
+
+      // r = 1
+      rtemp.assign(2, 1);
+      ctemp   = {13, 14};
+      valtemp = {std::cos(delta), -std::sin(delta)};
+      if (!refframe_)
+      {
+        rtemp.push_back(1);
+        ctemp.push_back(15);
+        valtemp.push_back(-std::sin(delta) * static_cast<RealT>(y_int_[10])
+                          - std::cos(delta) * static_cast<RealT>(y_int_[11]));
+      }
+      this->setJacValues(rtemp, ctemp, valtemp);
 
-    std::vector<IdxT>  ctemp{};
-    std::vector<IdxT>  rtemp{};
-    std::vector<RealT> valtemp{};
+      // r = 2
+      rtemp.assign(2, 2);
+      ctemp   = {13, 14};
+      valtemp = {std::sin(delta), std::cos(delta)};
+      if (!refframe_)
+      {
+        rtemp.push_back(2);
+        ctemp.push_back(15);
+        valtemp.push_back(std::cos(delta) * static_cast<RealT>(y_int_[10])
+                          - std::sin(delta) * static_cast<RealT>(y_int_[11]));
+      }
+      this->setJacValues(rtemp, ctemp, valtemp);
 
-    RealT delta = refframe_ ? RealT(0.0) : static_cast<RealT>(y_int_[12]);
+      // r = 3
+      rtemp.assign(5, 3);
+      ctemp   = {3, 11, 12, 13, 14};
+      valtemp = {-wc_ - alpha_,
+                 wc_ * static_cast<RealT>(y_int_[10]),
+                 wc_ * static_cast<RealT>(y_int_[11]),
+                 wc_ * static_cast<RealT>(y_int_[8]),
+                 wc_ * static_cast<RealT>(y_int_[9])};
+      this->setJacValues(rtemp, ctemp, valtemp);
 
-    // r = 0
-    if (refframe_)
-    {
-      rtemp.assign(2, 0);
-      ctemp   = {0, 3};
-      valtemp = {-1.0, -mp_};
+      // r = 4
+      rtemp.assign(5, 4);
+      ctemp   = {4, 11, 12, 13, 14};
+      valtemp = {-wc_ - alpha_,
+                 -wc_ * static_cast<RealT>(y_int_[11]),
+                 wc_ * static_cast<RealT>(y_int_[10]),
+                 wc_ * static_cast<RealT>(y_int_[9]),
+                 -wc_ * static_cast<RealT>(y_int_[8])};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 5
+      rtemp.assign(3, 5);
+      ctemp   = {4, 5, 11};
+      valtemp = {-nq_, -alpha_, -1.0};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 6
+      rtemp.assign(2, 6);
+      ctemp   = {6, 12};
+      valtemp = {-alpha_, -1.0};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 7
+      rtemp.assign(7, 7);
+      ctemp   = {4, 5, 7, 9, 11, 12, 13};
+      valtemp = {-Kpv_ * nq_, Kiv_, -alpha_, -1.0, -Kpv_, -Cf_ * wb_, F_};
       this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 8
+      rtemp.assign(6, 8);
+      ctemp   = {6, 8, 10, 11, 12, 14};
+      valtemp = {Kiv_, -alpha_, -1.0, Cf_ * wb_, -Kpv_, F_};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 9
+      rtemp.assign(9, 9);
+      ctemp   = {3, 4, 5, 7, 9, 10, 11, 12, 13};
+      valtemp = {-mp_ * static_cast<RealT>(y_int_[7]),
+                 -(Kpc_ * Kpv_ * nq_) / Lf_,
+                 (Kpc_ * Kiv_) / Lf_,
+                 Kic_ / Lf_,
+                 -(Kpc_ + rLf_) / Lf_ - alpha_,
+                 -mp_ * static_cast<RealT>(y_int_[0]),
+                 -(Kpc_ * Kpv_ + 1.0) / Lf_,
+                 -(Cf_ * Kpc_ * wb_) / Lf_,
+                 (F_ * Kpc_) / Lf_};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 10
+      rtemp.assign(8, 10);
+      ctemp   = {3, 6, 8, 9, 10, 11, 12, 14};
+      valtemp = {mp_ * static_cast<RealT>(y_int_[6]),
+                 (Kiv_ * Kpc_) / Lf_,
+                 Kic_ / Lf_,
+                 mp_ * static_cast<RealT>(y_int_[0]),
+                 -(Kpc_ + rLf_) / Lf_ - alpha_,
+                 (Cf_ * Kpc_ * wb_) / Lf_,
+                 -(Kpc_ * Kpv_ + 1.0) / Lf_,
+                 (F_ * Kpc_) / Lf_};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 11
+      rtemp.assign(5, 11);
+      ctemp   = {3, 9, 11, 12, 13};
+      valtemp = {-mp_ * static_cast<RealT>(y_int_[9]),
+                 1.0 / Cf_,
+                 -alpha_,
+                 wb_ - mp_ * static_cast<RealT>(y_int_[0]),
+                 -1.0 / Cf_};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 12
+      rtemp.assign(5, 12);
+      ctemp   = {3, 10, 11, 12, 14};
+      valtemp = {mp_ * static_cast<RealT>(y_int_[8]),
+                 1.0 / Cf_,
+                 -wb_ + mp_ * static_cast<RealT>(y_int_[0]),
+                 -alpha_,
+                 -1.0 / Cf_};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 13
+      rtemp.assign(6, 13);
+      ctemp   = {1, 2, 3, 11, 13, 14};
+      valtemp = {
+          (1.0 / Lc_) * -std::cos(delta),
+          (1.0 / Lc_) * -std::sin(delta),
+          -mp_ * static_cast<RealT>(y_int_[11]),
+          1.0 / Lc_,
+          -rLc_ / Lc_ - alpha_,
+          wb_ - mp_ * static_cast<RealT>(y_int_[0]),
+      };
+      if (!refframe_)
+      {
+        rtemp.push_back(13);
+        ctemp.push_back(15);
+        valtemp.push_back((1.0 / Lc_) * (std::sin(delta) * static_cast<RealT>(*y_ext_[1]) - std::cos(delta) * static_cast<RealT>(*y_ext_[2])));
+      }
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 14
+      rtemp.assign(6, 14);
+      ctemp   = {1, 2, 3, 12, 13, 14};
+      valtemp = {
+          (1.0 / Lc_) * std::sin(delta),
+          (1.0 / Lc_) * -std::cos(delta),
+          mp_ * static_cast<RealT>(y_int_[10]),
+          1.0 / Lc_,
+          -wb_ + mp_ * static_cast<RealT>(y_int_[0]),
+          -rLc_ / Lc_ - alpha_,
+      };
+      if (!refframe_)
+      {
+        rtemp.push_back(14);
+        ctemp.push_back(15);
+        valtemp.push_back((1.0 / Lc_) * (std::cos(delta) * static_cast<RealT>(*y_ext_[1]) + std::sin(delta) * static_cast<RealT>(*y_ext_[2])));
+      }
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      // r = 15
+      if (!refframe_)
+      {
+        rtemp.assign(3, 15);
+        ctemp   = {0, 3, 15};
+        valtemp = {-1.0, -mp_, -alpha_};
+        this->setJacValues(rtemp, ctemp, valtemp);
+      }
+
+      return 0;
     }
 
-    // r = 1
-    rtemp.assign(2, 1);
-    ctemp   = {13, 14};
-    valtemp = {std::cos(delta), -std::sin(delta)};
-    if (!refframe_)
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::allocate()
     {
-      rtemp.push_back(1);
-      ctemp.push_back(15);
-      valtemp.push_back(-std::sin(delta) * static_cast<RealT>(y_int_[10])
-                        - std::cos(delta) * static_cast<RealT>(y_int_[11]));
+      CircuitComponent<ScalarT, IdxT>::allocate();
+
+      this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
+      this->setExternalConnectionNodes(1, node_bus_->getNodeConnection(0));
+      this->setExternalConnectionNodes(2, node_bus_->getNodeConnection(1));
+
+      return 0;
     }
-    this->setJacValues(rtemp, ctemp, valtemp);
 
-    // r = 2
-    rtemp.assign(2, 2);
-    ctemp   = {13, 14};
-    valtemp = {std::sin(delta), std::cos(delta)};
-    if (!refframe_)
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::evaluateIntegrand()
     {
-      rtemp.push_back(2);
-      ctemp.push_back(15);
-      valtemp.push_back(std::cos(delta) * static_cast<RealT>(y_int_[10])
-                        - std::sin(delta) * static_cast<RealT>(y_int_[11]));
+      return 0;
     }
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 3
-    rtemp.assign(5, 3);
-    ctemp   = {3, 11, 12, 13, 14};
-    valtemp = {-wc_ - alpha_,
-               wc_ * static_cast<RealT>(y_int_[10]),
-               wc_ * static_cast<RealT>(y_int_[11]),
-               wc_ * static_cast<RealT>(y_int_[8]),
-               wc_ * static_cast<RealT>(y_int_[9])};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 4
-    rtemp.assign(5, 4);
-    ctemp   = {4, 11, 12, 13, 14};
-    valtemp = {-wc_ - alpha_,
-               -wc_ * static_cast<RealT>(y_int_[11]),
-               wc_ * static_cast<RealT>(y_int_[10]),
-               wc_ * static_cast<RealT>(y_int_[9]),
-               -wc_ * static_cast<RealT>(y_int_[8])};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 5
-    rtemp.assign(3, 5);
-    ctemp   = {4, 5, 11};
-    valtemp = {-nq_, -alpha_, -1.0};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 6
-    rtemp.assign(2, 6);
-    ctemp   = {6, 12};
-    valtemp = {-alpha_, -1.0};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 7
-    rtemp.assign(7, 7);
-    ctemp   = {4, 5, 7, 9, 11, 12, 13};
-    valtemp = {-Kpv_ * nq_, Kiv_, -alpha_, -1.0, -Kpv_, -Cf_ * wb_, F_};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 8
-    rtemp.assign(6, 8);
-    ctemp   = {6, 8, 10, 11, 12, 14};
-    valtemp = {Kiv_, -alpha_, -1.0, Cf_ * wb_, -Kpv_, F_};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 9
-    rtemp.assign(9, 9);
-    ctemp   = {3, 4, 5, 7, 9, 10, 11, 12, 13};
-    valtemp = {-mp_ * static_cast<RealT>(y_int_[7]),
-               -(Kpc_ * Kpv_ * nq_) / Lf_,
-               (Kpc_ * Kiv_) / Lf_,
-               Kic_ / Lf_,
-               -(Kpc_ + rLf_) / Lf_ - alpha_,
-               -mp_ * static_cast<RealT>(y_int_[0]),
-               -(Kpc_ * Kpv_ + 1.0) / Lf_,
-               -(Cf_ * Kpc_ * wb_) / Lf_,
-               (F_ * Kpc_) / Lf_};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 10
-    rtemp.assign(8, 10);
-    ctemp   = {3, 6, 8, 9, 10, 11, 12, 14};
-    valtemp = {mp_ * static_cast<RealT>(y_int_[6]),
-               (Kiv_ * Kpc_) / Lf_,
-               Kic_ / Lf_,
-               mp_ * static_cast<RealT>(y_int_[0]),
-               -(Kpc_ + rLf_) / Lf_ - alpha_,
-               (Cf_ * Kpc_ * wb_) / Lf_,
-               -(Kpc_ * Kpv_ + 1.0) / Lf_,
-               (F_ * Kpc_) / Lf_};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 11
-    rtemp.assign(5, 11);
-    ctemp   = {3, 9, 11, 12, 13};
-    valtemp = {-mp_ * static_cast<RealT>(y_int_[9]),
-               1.0 / Cf_,
-               -alpha_,
-               wb_ - mp_ * static_cast<RealT>(y_int_[0]),
-               -1.0 / Cf_};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 12
-    rtemp.assign(5, 12);
-    ctemp   = {3, 10, 11, 12, 14};
-    valtemp = {mp_ * static_cast<RealT>(y_int_[8]),
-               1.0 / Cf_,
-               -wb_ + mp_ * static_cast<RealT>(y_int_[0]),
-               -alpha_,
-               -1.0 / Cf_};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 13
-    rtemp.assign(6, 13);
-    ctemp   = {1, 2, 3, 11, 13, 14};
-    valtemp = {
-        (1.0 / Lc_) * -std::cos(delta),
-        (1.0 / Lc_) * -std::sin(delta),
-        -mp_ * static_cast<RealT>(y_int_[11]),
-        1.0 / Lc_,
-        -rLc_ / Lc_ - alpha_,
-        wb_ - mp_ * static_cast<RealT>(y_int_[0]),
-    };
-    if (!refframe_)
+
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::initializeAdjoint()
     {
-      rtemp.push_back(13);
-      ctemp.push_back(15);
-      valtemp.push_back((1.0 / Lc_) * (std::sin(delta) * static_cast<RealT>(*y_ext_[1]) - std::cos(delta) * static_cast<RealT>(*y_ext_[2])));
+      return 0;
     }
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    // r = 14
-    rtemp.assign(6, 14);
-    ctemp   = {1, 2, 3, 12, 13, 14};
-    valtemp = {
-        (1.0 / Lc_) * std::sin(delta),
-        (1.0 / Lc_) * -std::cos(delta),
-        mp_ * static_cast<RealT>(y_int_[10]),
-        1.0 / Lc_,
-        -wb_ + mp_ * static_cast<RealT>(y_int_[0]),
-        -rLc_ / Lc_ - alpha_,
-    };
-    if (!refframe_)
+
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::evaluateAdjointResidual()
     {
-      rtemp.push_back(14);
-      ctemp.push_back(15);
-      valtemp.push_back((1.0 / Lc_) * (std::cos(delta) * static_cast<RealT>(*y_ext_[1]) + std::sin(delta) * static_cast<RealT>(*y_ext_[2])));
+      return 0;
     }
-    this->setJacValues(rtemp, ctemp, valtemp);
 
-    // r = 15
-    if (!refframe_)
+    template <class ScalarT, typename IdxT>
+    int DistributedGenerator<ScalarT, IdxT>::evaluateAdjointIntegrand()
     {
-      rtemp.assign(3, 15);
-      ctemp   = {0, 3, 15};
-      valtemp = {-1.0, -mp_, -alpha_};
-      this->setJacValues(rtemp, ctemp, valtemp);
+      return 0;
     }
 
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::allocate()
-  {
-    CircuitComponent<ScalarT, IdxT>::allocate();
-
-    this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
-    this->setExternalConnectionNodes(1, node_bus_->getNodeConnection(0));
-    this->setExternalConnectionNodes(2, node_bus_->getNodeConnection(1));
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int DistributedGenerator<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* DistributedGenerator<ScalarT, IdxT>::clone() const
-  {
-    return new DistributedGenerator<ScalarT, IdxT>(*this);
-  }
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* DistributedGenerator<ScalarT, IdxT>::clone() const
+    {
+      return new DistributedGenerator<ScalarT, IdxT>(*this);
+    }
 
-  // Available template instantiations
-  template class DistributedGenerator<double, long int>;
-  template class DistributedGenerator<double, size_t>;
-  template class DistributedGenerator<DependencyTracking::Variable, long int>;
-  template class DistributedGenerator<DependencyTracking::Variable, size_t>;
+    // Available template instantiations
+    template class DistributedGenerator<double, long int>;
+    template class DistributedGenerator<double, size_t>;
+    template class DistributedGenerator<DependencyTracking::Variable, long int>;
+    template class DistributedGenerator<DependencyTracking::Variable, size_t>;
 
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp
index 11d6f9e97..b67ff2b98 100644
--- a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp
+++ b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -7,108 +6,109 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-
-  template <typename RealT, typename IdxT>
-  struct DistributedGeneratorParameters
+  namespace PowerElectronics
   {
-    RealT wb_;
-    RealT wc_;
-    RealT mp_;
-    RealT Vn_;
-    RealT nq_;
-    RealT F_;
-    RealT Kiv_;
-    RealT Kpv_;
-    RealT Kic_;
-    RealT Kpc_;
-    RealT Cf_;
-    RealT rLf_;
-    RealT Lf_;
-    RealT rLc_;
-    RealT Lc_;
-  };
-} // namespace GridKit
+    /*!
+     * @brief Declaration of a DistributedGenerator parameter struct.
+     *
+     */
+    template <typename RealT, typename IdxT>
+    struct DistributedGeneratorParameters
+    {
+      RealT wb_;
+      RealT wc_;
+      RealT mp_;
+      RealT Vn_;
+      RealT nq_;
+      RealT F_;
+      RealT Kiv_;
+      RealT Kpv_;
+      RealT Kic_;
+      RealT Kpc_;
+      RealT Cf_;
+      RealT rLf_;
+      RealT Lf_;
+      RealT rLc_;
+      RealT Lc_;
+    };
 
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a DistributedGenerator class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class DistributedGenerator : public CircuitComponent<ScalarT, IdxT>
-  {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
+    /*!
+     * @brief Declaration of a DistributedGenerator class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class DistributedGenerator : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    DistributedGenerator(IdxT                                        id,
-                         DistributedGeneratorParameters<RealT, IdxT> parm,
-                         bool                                        reference_frame,
-                         NodeT*                                      node_ref,
-                         NodeT*                                      node_bus);
-    virtual ~DistributedGenerator();
+    public:
+      DistributedGenerator(IdxT                                        id,
+                           DistributedGeneratorParameters<RealT, IdxT> parm,
+                           bool                                        reference_frame,
+                           NodeT*                                      node_ref,
+                           NodeT*                                      node_bus);
+      virtual ~DistributedGenerator();
 
-    int initialize();
-    int allocate() final;
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initialize();
+      int allocate() final;
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT wb_;
-    RealT wc_;
-    RealT mp_;
-    RealT Vn_;
-    RealT nq_;
-    RealT F_;
-    RealT Kiv_;
-    RealT Kpv_;
-    RealT Kic_;
-    RealT Kpc_;
-    RealT Cf_;
-    RealT rLf_;
-    RealT Lf_;
-    RealT rLc_;
-    RealT Lc_;
-    bool  refframe_;
+    private:
+      RealT wb_;
+      RealT wc_;
+      RealT mp_;
+      RealT Vn_;
+      RealT nq_;
+      RealT F_;
+      RealT Kiv_;
+      RealT Kpv_;
+      RealT Kic_;
+      RealT Kpc_;
+      RealT Cf_;
+      RealT rLf_;
+      RealT Lf_;
+      RealT rLc_;
+      RealT Lc_;
+      bool  refframe_;
 
-    NodeT* node_ref_;
-    NodeT* node_bus_;
-  };
+      NodeT* node_ref_;
+      NodeT* node_bus_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/ExternalConnection.hpp b/GridKit/Model/PowerElectronics/ExternalConnection.hpp
index 5edf9a7e8..2cc6a1e27 100644
--- a/GridKit/Model/PowerElectronics/ExternalConnection.hpp
+++ b/GridKit/Model/PowerElectronics/ExternalConnection.hpp
@@ -2,22 +2,25 @@
 
 namespace GridKit
 {
-  /**
-   * @brief The connection of a component's external variable to its system.
-   * Allows the component to access data about that external variable and allows
-   * the system to construct Jacobian information about that variable.
-   * @see CircuitComponent::setExternalConnectionNodes()
-   */
-  template <class ScalarT, typename IdxT>
-  struct ExternalConnection
+  namespace PowerElectronics
   {
-    /// A pointer to the state value of the variable. \see CircuitComponent::y_ext_
-    const ScalarT* y_;
-    /// A pointer to the derivative value of the variable. \see CircuitComponent::yp_ext_
-    const ScalarT* yp_;
-    /// A pointer to the residual buffer of the variable. \see CircuitComponent::f_ext_
-    ScalarT*       f_;
-    /// The corresponding system variable index. \see CircuitComponent::connection_nodes_
-    IdxT           idx_;
-  };
+    /**
+     * @brief The connection of a component's external variable to its system.
+     * Allows the component to access data about that external variable and allows
+     * the system to construct Jacobian information about that variable.
+     * @see CircuitComponent::setExternalConnectionNodes()
+     */
+    template <class ScalarT, typename IdxT>
+    struct ExternalConnection
+    {
+      /// A pointer to the state value of the variable. \see CircuitComponent::y_ext_
+      const ScalarT* y_;
+      /// A pointer to the derivative value of the variable. \see CircuitComponent::yp_ext_
+      const ScalarT* yp_;
+      /// A pointer to the residual buffer of the variable. \see CircuitComponent::f_ext_
+      ScalarT*       f_;
+      /// The corresponding system variable index. \see CircuitComponent::connection_nodes_
+      IdxT           idx_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp
index 0c7c87761..dd2f00851 100644
--- a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp
+++ b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp
@@ -1,5 +1,4 @@
 
-
 #include "InductionMotor.hpp"
 
 #include <cmath>
@@ -8,158 +7,159 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a constant InductionMotor model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   * @todo create a test case utilizing the component.
-   * @todo create a unit test to check correctness of component
-   *
-   * @tparam ScalarT - data type for scalar variables in the model
-   * @tparam IdxT - integer index type for the model
-   *
-   * @param[in] id - unique identifier for the component
-   * @param[in] Lls - stator leakage inductance
-   */
-
-  template <class ScalarT, typename IdxT>
-  InductionMotor<ScalarT, IdxT>::InductionMotor(IdxT id, RealT Lls, RealT Rs, RealT Llr, RealT Rr, RealT Lms, RealT RJ, RealT P)
-    : Lls_(Lls),
-      Rs_(Rs),
-      Llr_(Llr),
-      Rr_(Rr),
-      Lms_(Lms),
-      RJ_(RJ),
-      P_(P)
-  {
-    size_           = 10;
-    n_intern_       = 5;
-    n_extern_       = 5;
-    extern_indices_ = {0, 1, 2, 3, 4};
-    idc_            = id;
-  }
-
-  template <class ScalarT, typename IdxT>
-  InductionMotor<ScalarT, IdxT>::~InductionMotor()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::tagDifferentiable()
+  namespace PowerElectronics
   {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Contributes to the resisdual
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    f_int_[0] = (1.0 / 3.0) * (2.0 * *y_ext_[0] - *y_ext_[1] - *y_ext_[2]) - Rs_ * y_int_[0] - (Lls_ + Lms_) * yp_int_[0] - Lms_ * yp_int_[1];
-    f_int_[1] = (1.0 / std::sqrt(3.0)) * (-*y_ext_[1] + *y_ext_[2]) - Rs_ * y_int_[1] - (Lls_ + Lms_) * yp_int_[1] - Lms_ * yp_int_[0];
-    f_int_[2] = (*y_ext_[0] + *y_ext_[1] + *y_ext_[2]) / 3.0 - Rs_ * y_int_[2] - Lls_ * yp_int_[7];
-    f_int_[3] = Rr_ * y_int_[3] + (Llr_ + Lms_) * yp_int_[3] + Lms_ * yp_int_[0] - (P_ / 2.0) * *y_ext_[3] * ((Llr_ + Lms_) * y_int_[4] + Lms_ * y_int_[1]);
-    f_int_[4] = Rr_ * y_int_[4] + (Llr_ + Lms_) * yp_int_[4] + Lms_ * yp_int_[1] + (P_ / 2.0) * *y_ext_[3] * ((Llr_ + Lms_) * y_int_[3] + Lms_ * y_int_[0]);
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    *f_ext_[0] += y_int_[0] + y_int_[2];
-    *f_ext_[1] += (-1.0 / 2.0) * y_int_[0] - (std::sqrt(3.0) / 2.0) * y_int_[1] + y_int_[2];
-    *f_ext_[2] += (-1.0 / 2.0) * y_int_[0] + (std::sqrt(3.0) / 2.0) * y_int_[1] + y_int_[2];
-    *f_ext_[3] += RJ_ * *yp_ext_[3] - (3.0 / 4.0) * P_ * Lms_ * (y_int_[0] * y_int_[4] - y_int_[1] * y_int_[3]);
-    *f_ext_[4] += *yp_ext_[4] - *y_ext_[3];
-    return 0;
-  }
-
-  /**
-   * @brief Compute component Jacobian
-   *
-   * @todo need to implement
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::evaluateJacobian()
-  {
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int InductionMotor<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* InductionMotor<ScalarT, IdxT>::clone() const
-  {
-    return new InductionMotor<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class InductionMotor<double, long int>;
-  template class InductionMotor<double, size_t>;
-  template class InductionMotor<DependencyTracking::Variable, long int>;
-  template class InductionMotor<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a constant InductionMotor model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     * @todo create a test case utilizing the component.
+     * @todo create a unit test to check correctness of component
+     *
+     * @tparam ScalarT - data type for scalar variables in the model
+     * @tparam IdxT - integer index type for the model
+     *
+     * @param[in] id - unique identifier for the component
+     * @param[in] Lls - stator leakage inductance
+     */
+    template <class ScalarT, typename IdxT>
+    InductionMotor<ScalarT, IdxT>::InductionMotor(IdxT id, RealT Lls, RealT Rs, RealT Llr, RealT Rr, RealT Lms, RealT RJ, RealT P)
+      : Lls_(Lls),
+        Rs_(Rs),
+        Llr_(Llr),
+        Rr_(Rr),
+        Lms_(Lms),
+        RJ_(RJ),
+        P_(P)
+    {
+      size_           = 10;
+      n_intern_       = 5;
+      n_extern_       = 5;
+      extern_indices_ = {0, 1, 2, 3, 4};
+      idc_            = id;
+    }
+
+    template <class ScalarT, typename IdxT>
+    InductionMotor<ScalarT, IdxT>::~InductionMotor()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Contributes to the resisdual
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      f_int_[0] = (1.0 / 3.0) * (2.0 * *y_ext_[0] - *y_ext_[1] - *y_ext_[2]) - Rs_ * y_int_[0] - (Lls_ + Lms_) * yp_int_[0] - Lms_ * yp_int_[1];
+      f_int_[1] = (1.0 / std::sqrt(3.0)) * (-*y_ext_[1] + *y_ext_[2]) - Rs_ * y_int_[1] - (Lls_ + Lms_) * yp_int_[1] - Lms_ * yp_int_[0];
+      f_int_[2] = (*y_ext_[0] + *y_ext_[1] + *y_ext_[2]) / 3.0 - Rs_ * y_int_[2] - Lls_ * yp_int_[7];
+      f_int_[3] = Rr_ * y_int_[3] + (Llr_ + Lms_) * yp_int_[3] + Lms_ * yp_int_[0] - (P_ / 2.0) * *y_ext_[3] * ((Llr_ + Lms_) * y_int_[4] + Lms_ * y_int_[1]);
+      f_int_[4] = Rr_ * y_int_[4] + (Llr_ + Lms_) * yp_int_[4] + Lms_ * yp_int_[1] + (P_ / 2.0) * *y_ext_[3] * ((Llr_ + Lms_) * y_int_[3] + Lms_ * y_int_[0]);
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      *f_ext_[0] += y_int_[0] + y_int_[2];
+      *f_ext_[1] += (-1.0 / 2.0) * y_int_[0] - (std::sqrt(3.0) / 2.0) * y_int_[1] + y_int_[2];
+      *f_ext_[2] += (-1.0 / 2.0) * y_int_[0] + (std::sqrt(3.0) / 2.0) * y_int_[1] + y_int_[2];
+      *f_ext_[3] += RJ_ * *yp_ext_[3] - (3.0 / 4.0) * P_ * Lms_ * (y_int_[0] * y_int_[4] - y_int_[1] * y_int_[3]);
+      *f_ext_[4] += *yp_ext_[4] - *y_ext_[3];
+      return 0;
+    }
+
+    /**
+     * @brief Compute component Jacobian
+     *
+     * @todo need to implement
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::evaluateJacobian()
+    {
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int InductionMotor<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* InductionMotor<ScalarT, IdxT>::clone() const
+    {
+      return new InductionMotor<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class InductionMotor<double, long int>;
+    template class InductionMotor<double, size_t>;
+    template class InductionMotor<DependencyTracking::Variable, long int>;
+    template class InductionMotor<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp
index 13ed162ec..d68866010 100644
--- a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp
+++ b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp
@@ -1,76 +1,72 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a InductionMotor class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class InductionMotor : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+    /*!
+     * @brief Declaration of a InductionMotor class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class InductionMotor : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    InductionMotor(IdxT id, RealT Lls, RealT Rs, RealT Llr, RealT Rr, RealT Lms, RealT RJ, RealT P);
-    virtual ~InductionMotor();
+    public:
+      InductionMotor(IdxT id, RealT Lls, RealT Rs, RealT Llr, RealT Rr, RealT Lms, RealT RJ, RealT P);
+      virtual ~InductionMotor();
 
-    int initialize();
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT Lls_;
-    RealT Rs_;
-    RealT Llr_;
-    RealT Rr_;
-    RealT Lms_;
-    RealT RJ_;
-    RealT P_;
-  };
+    private:
+      RealT Lls_;
+      RealT Rs_;
+      RealT Llr_;
+      RealT Rr_;
+      RealT Lms_;
+      RealT RJ_;
+      RealT P_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp b/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp
index 42c15c6a5..2e38e35de 100644
--- a/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp
+++ b/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp
@@ -1,5 +1,4 @@
 
-
 #include "Inductor.hpp"
 
 #include <cmath>
@@ -7,158 +6,159 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a inductor
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   */
-
-  template <class ScalarT, typename IdxT>
-  Inductor<ScalarT, IdxT>::Inductor(IdxT id, RealT L, NodeT* node1, NodeT* node2)
-    : L_(L), node1_(node1), node2_(node2)
-  {
-    assert(node1_->size() == 1);
-    assert(node2_->size() == 1);
-    size_           = 3;
-    n_intern_       = 1;
-    n_extern_       = 2;
-    extern_indices_ = {0, 1};
-    idc_            = id;
-    nnz_            = 5;
-  }
-
-  template <class ScalarT, typename IdxT>
-  Inductor<ScalarT, IdxT>::~Inductor()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Compute the resisdual of the component
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    f_int_[0] = -L_ * yp_int_[0] + *y_ext_[1] - *y_ext_[0];
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // input
-    *f_ext_[0] += -y_int_[0];
-    // output
-    *f_ext_[1] += y_int_[0];
-    return 0;
-  }
-
-  /**
-   * @brief Evaluate the jacobian of the component
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
-
-    // Create dF/dy
-    std::vector<IdxT>  rcord{0, 1, 2, 2, 2};
-    std::vector<IdxT>  ccord{2, 2, 0, 1, 2};
-    std::vector<RealT> vals{-1.0, 1.0, -1.0, 1.0, -L_ * alpha_};
-    this->setJacValues(rcord, ccord, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::allocate()
-  {
-    CircuitComponent<ScalarT, IdxT>::allocate();
-
-    this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
-    this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::initializeAdjoint()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Inductor<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* Inductor<ScalarT, IdxT>::clone() const
-  {
-    return new Inductor<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class Inductor<double, long int>;
-  template class Inductor<double, size_t>;
-  template class Inductor<DependencyTracking::Variable, long int>;
-  template class Inductor<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a inductor
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     */
+    template <class ScalarT, typename IdxT>
+    Inductor<ScalarT, IdxT>::Inductor(IdxT id, RealT L, NodeT* node1, NodeT* node2)
+      : L_(L), node1_(node1), node2_(node2)
+    {
+      assert(node1_->size() == 1);
+      assert(node2_->size() == 1);
+      size_           = 3;
+      n_intern_       = 1;
+      n_extern_       = 2;
+      extern_indices_ = {0, 1};
+      idc_            = id;
+      nnz_            = 5;
+    }
+
+    template <class ScalarT, typename IdxT>
+    Inductor<ScalarT, IdxT>::~Inductor()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Compute the resisdual of the component
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      f_int_[0] = -L_ * yp_int_[0] + *y_ext_[1] - *y_ext_[0];
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // input
+      *f_ext_[0] += -y_int_[0];
+      // output
+      *f_ext_[1] += y_int_[0];
+      return 0;
+    }
+
+    /**
+     * @brief Evaluate the jacobian of the component
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      // Create dF/dy
+      std::vector<IdxT>  rcord{0, 1, 2, 2, 2};
+      std::vector<IdxT>  ccord{2, 2, 0, 1, 2};
+      std::vector<RealT> vals{-1.0, 1.0, -1.0, 1.0, -L_ * alpha_};
+      this->setJacValues(rcord, ccord, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::allocate()
+    {
+      CircuitComponent<ScalarT, IdxT>::allocate();
+
+      this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
+      this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Inductor<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* Inductor<ScalarT, IdxT>::clone() const
+    {
+      return new Inductor<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class Inductor<double, long int>;
+    template class Inductor<double, size_t>;
+    template class Inductor<DependencyTracking::Variable, long int>;
+    template class Inductor<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp b/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp
index 7440037c9..fb69dc871 100644
--- a/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp
+++ b/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -7,69 +6,66 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a Inductor class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class Inductor : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
+    /*!
+     * @brief Declaration of a Inductor class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class Inductor : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    Inductor(IdxT id, RealT L, NodeT* node1, NodeT* node2);
-    virtual ~Inductor();
+    public:
+      Inductor(IdxT id, RealT L, NodeT* node1, NodeT* node2);
+      virtual ~Inductor();
 
-    int initialize();
-    int allocate() final;
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int allocate() final;
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT  L_;
-    NodeT* node1_;
-    NodeT* node2_;
-  };
+    private:
+      RealT  L_;
+      NodeT* node1_;
+      NodeT* node2_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp
index b3b909ebb..3a8cc282a 100644
--- a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp
+++ b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp
@@ -1,5 +1,4 @@
 
-
 #include "LinearTransformer.hpp"
 
 #include <cmath>
@@ -8,143 +7,144 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a LinearTransformer model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   * @todo Not tested in any model yet. Should be
-   * @todo Has not been tested for correctness
-   *
-   * @tparam ScalarT - floating point type for the model
-   * @tparam IdxT - integer index type for the model
-   *
-   * @param[in] id - unique identifier for the component
-   * @param[in] L0 - inductance 0
-   * @param[in] L1 - inductance 1
-   * @param[in] R0 - resistance 0
-   * @param[in] R1 - resistance 1
-   * @param[in] M - mutual inductance
-   */
-
-  template <class ScalarT, typename IdxT>
-  LinearTransformer<ScalarT, IdxT>::LinearTransformer(IdxT id, RealT L0, RealT L1, RealT R0, RealT R1, RealT M)
-    : L0_(L0),
-      L1_(L1),
-      R0_(R0),
-      R1_(R1),
-      M_(M)
-  {
-    size_           = 4;
-    n_intern_       = 2;
-    n_extern_       = 2;
-    extern_indices_ = {0, 1};
-    idc_            = id;
-  }
-
-  template <class ScalarT, typename IdxT>
-  LinearTransformer<ScalarT, IdxT>::~LinearTransformer()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Computes the component resisdual
-   */
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    f_int_[0] = *y_ext_[0] - R0_ * y_int_[0] - L0_ * yp_int_[0] - M_ * yp_int_[1];
-    f_int_[1] = *y_ext_[1] - R1_ * y_int_[1] - M_ * yp_int_[0] - L1_ * yp_int_[1];
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    *f_ext_[0] += y_int_[0];
-    *f_ext_[1] += y_int_[1];
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::evaluateJacobian()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int LinearTransformer<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* LinearTransformer<ScalarT, IdxT>::clone() const
-  {
-    return new LinearTransformer<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class LinearTransformer<double, long int>;
-  template class LinearTransformer<double, size_t>;
-  template class LinearTransformer<DependencyTracking::Variable, long int>;
-  template class LinearTransformer<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a LinearTransformer model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     * @todo Not tested in any model yet. Should be
+     * @todo Has not been tested for correctness
+     *
+     * @tparam ScalarT - floating point type for the model
+     * @tparam IdxT - integer index type for the model
+     *
+     * @param[in] id - unique identifier for the component
+     * @param[in] L0 - inductance 0
+     * @param[in] L1 - inductance 1
+     * @param[in] R0 - resistance 0
+     * @param[in] R1 - resistance 1
+     * @param[in] M - mutual inductance
+     */
+    template <class ScalarT, typename IdxT>
+    LinearTransformer<ScalarT, IdxT>::LinearTransformer(IdxT id, RealT L0, RealT L1, RealT R0, RealT R1, RealT M)
+      : L0_(L0),
+        L1_(L1),
+        R0_(R0),
+        R1_(R1),
+        M_(M)
+    {
+      size_           = 4;
+      n_intern_       = 2;
+      n_extern_       = 2;
+      extern_indices_ = {0, 1};
+      idc_            = id;
+    }
+
+    template <class ScalarT, typename IdxT>
+    LinearTransformer<ScalarT, IdxT>::~LinearTransformer()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Computes the component resisdual
+     */
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      f_int_[0] = *y_ext_[0] - R0_ * y_int_[0] - L0_ * yp_int_[0] - M_ * yp_int_[1];
+      f_int_[1] = *y_ext_[1] - R1_ * y_int_[1] - M_ * yp_int_[0] - L1_ * yp_int_[1];
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      *f_ext_[0] += y_int_[0];
+      *f_ext_[1] += y_int_[1];
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::evaluateJacobian()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int LinearTransformer<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* LinearTransformer<ScalarT, IdxT>::clone() const
+    {
+      return new LinearTransformer<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class LinearTransformer<double, long int>;
+    template class LinearTransformer<double, size_t>;
+    template class LinearTransformer<DependencyTracking::Variable, long int>;
+    template class LinearTransformer<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp
index 0785dcb32..047ed0fe4 100644
--- a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp
+++ b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp
@@ -1,74 +1,70 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a LinearTransformer class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class LinearTransformer : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+    /*!
+     * @brief Declaration of a LinearTransformer class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class LinearTransformer : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    LinearTransformer(IdxT id, RealT L0, RealT L1, RealT R0, RealT R1, RealT M);
-    virtual ~LinearTransformer();
+    public:
+      LinearTransformer(IdxT id, RealT L0, RealT L1, RealT R0, RealT R1, RealT M);
+      virtual ~LinearTransformer();
 
-    int initialize();
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT L0_;
-    RealT L1_;
-    RealT R0_;
-    RealT R1_;
-    RealT M_;
-  };
+    private:
+      RealT L0_;
+      RealT L1_;
+      RealT R0_;
+      RealT R1_;
+      RealT M_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp
index a918eaf9d..95d20b8e8 100644
--- a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp
+++ b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp
@@ -7,161 +7,163 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a constant MicrogridBusDQ model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   *
-   * In DQ space
-   * Each microgrid line has a virtual resistance RN
-   * Model is from paper: "Modeling, Analysis and Testing of Autonomous Operation
-   * of an Inverter-Based Microgrid", Nagaraju Pogaku, Milan Prodanovic, and
-   * Timothy C. Green, Section E
-   */
-  template <class ScalarT, typename IdxT>
-  MicrogridBusDQ<ScalarT, IdxT>::MicrogridBusDQ(IdxT id, RealT RN, NodeT* node1)
-    : RN_(RN), node1_(node1)
-  {
-    assert(node1_->size() == 2);
-    // externals [vbus_d, vbus_q]
-    size_           = 2;
-    n_intern_       = 0;
-    n_extern_       = 2;
-    extern_indices_ = {0, 1};
-    idc_            = id;
-    nnz_            = 2;
-  }
-
-  template <class ScalarT, typename IdxT>
-  MicrogridBusDQ<ScalarT, IdxT>::~MicrogridBusDQ()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /// There are no internal variables in this component, so \ref tag_ can be set arbitrarily.
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::tagDifferentiable()
-  {
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::setAbsoluteTolerance(RealT)
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    return 0;
-  }
-
-  /**
-   * @brief Evaluate residual
-   * This model has "Virtual resistors". The voltage of the bus divided by its virtual resistance.
-   * The components are external to allow for outside components to add inductances to the terms.
-   *
-   * refernce to equations in class header
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // bus voltage
-    *f_ext_[0] += -*y_ext_[0] / RN_;
-    *f_ext_[1] += -*y_ext_[1] / RN_;
-
-    return 0;
-  }
-
-  /**
-   * @brief Generate Jacobian
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
-
-    // Create dF/dy
-    std::vector<IdxT>  rtemp{0, 1};
-    std::vector<IdxT>  ctemp{0, 1};
-    std::vector<RealT> vals{-1.0 / RN_, -1.0 / RN_};
-    this->setJacValues(rtemp, ctemp, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::allocate()
+  namespace PowerElectronics
   {
-    CircuitComponent<ScalarT, IdxT>::allocate();
-
-    this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
-    this->setExternalConnectionNodes(1, node1_->getNodeConnection(1));
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridBusDQ<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* MicrogridBusDQ<ScalarT, IdxT>::clone() const
-  {
-    return new MicrogridBusDQ<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class MicrogridBusDQ<double, long int>;
-  template class MicrogridBusDQ<double, size_t>;
-  template class MicrogridBusDQ<DependencyTracking::Variable, long int>;
-  template class MicrogridBusDQ<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a constant MicrogridBusDQ model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     *
+     * In DQ space
+     * Each microgrid line has a virtual resistance RN
+     * Model is from paper: "Modeling, Analysis and Testing of Autonomous Operation
+     * of an Inverter-Based Microgrid", Nagaraju Pogaku, Milan Prodanovic, and
+     * Timothy C. Green, Section E
+     */
+    template <class ScalarT, typename IdxT>
+    MicrogridBusDQ<ScalarT, IdxT>::MicrogridBusDQ(IdxT id, RealT RN, NodeT* node1)
+      : RN_(RN), node1_(node1)
+    {
+      assert(node1_->size() == 2);
+      // externals [vbus_d, vbus_q]
+      size_           = 2;
+      n_intern_       = 0;
+      n_extern_       = 2;
+      extern_indices_ = {0, 1};
+      idc_            = id;
+      nnz_            = 2;
+    }
+
+    template <class ScalarT, typename IdxT>
+    MicrogridBusDQ<ScalarT, IdxT>::~MicrogridBusDQ()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /// There are no internal variables in this component, so \ref tag_ can be set arbitrarily.
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::tagDifferentiable()
+    {
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::setAbsoluteTolerance(RealT)
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      return 0;
+    }
+
+    /**
+     * @brief Evaluate residual
+     * This model has "Virtual resistors". The voltage of the bus divided by its virtual resistance.
+     * The components are external to allow for outside components to add inductances to the terms.
+     *
+     * refernce to equations in class header
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // bus voltage
+      *f_ext_[0] += -*y_ext_[0] / RN_;
+      *f_ext_[1] += -*y_ext_[1] / RN_;
+
+      return 0;
+    }
+
+    /**
+     * @brief Generate Jacobian
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      // Create dF/dy
+      std::vector<IdxT>  rtemp{0, 1};
+      std::vector<IdxT>  ctemp{0, 1};
+      std::vector<RealT> vals{-1.0 / RN_, -1.0 / RN_};
+      this->setJacValues(rtemp, ctemp, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::allocate()
+    {
+      CircuitComponent<ScalarT, IdxT>::allocate();
+
+      this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
+      this->setExternalConnectionNodes(1, node1_->getNodeConnection(1));
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridBusDQ<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* MicrogridBusDQ<ScalarT, IdxT>::clone() const
+    {
+      return new MicrogridBusDQ<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class MicrogridBusDQ<double, long int>;
+    template class MicrogridBusDQ<double, size_t>;
+    template class MicrogridBusDQ<DependencyTracking::Variable, long int>;
+    template class MicrogridBusDQ<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp
index 806dd2751..e1d44fce1 100644
--- a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp
+++ b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -7,68 +6,65 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a MicrogridBusDQ class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class MicrogridBusDQ : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
+    /*!
+     * @brief Declaration of a MicrogridBusDQ class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class MicrogridBusDQ : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    MicrogridBusDQ(IdxT id, RealT RN, NodeT* node1);
-    virtual ~MicrogridBusDQ();
+    public:
+      MicrogridBusDQ(IdxT id, RealT RN, NodeT* node1);
+      virtual ~MicrogridBusDQ();
 
-    int initialize();
-    int allocate() final;
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int allocate() final;
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT  RN_;
-    NodeT* node1_;
-  };
+    private:
+      RealT  RN_;
+      NodeT* node1_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp
index 7dc2f6b80..746ed2d54 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp
@@ -7,193 +7,194 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a constant MicrogridLine model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   *
-   *
-   * Model is from paper: "Modeling, Analysis and Testing of Autonomous Operation
-   * of an Inverter-Based Microgrid", Nagaraju Pogaku, Milan Prodanovic, and
-   * Timothy C. Green, Section C
-   *
-   * @todo Consider having \omegaref as a global constant, not a node variable.
-   */
-
-  template <class ScalarT, typename IdxT>
-  MicrogridLine<ScalarT, IdxT>::MicrogridLine(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* bus1, NodeT* bus2)
-    : R_(R),
-      L_(L),
-      node_ref_(node_ref),
-      bus1_(bus1),
-      bus2_(bus2)
-  {
-    assert(node_ref_->size() == 1);
-    assert(bus1_->size() == 2);
-    assert(bus2_->size() == 2);
-    // internals [id, iq]
-    // externals [\omegaref, vbd_in, vbq_in, vbd_out, vbq_out]
-    size_           = 7;
-    n_intern_       = 2;
-    n_extern_       = 5;
-    extern_indices_ = {0, 1, 2, 3, 4};
-    idc_            = id;
-    nnz_            = 14;
-  }
-
-  template <class ScalarT, typename IdxT>
-  MicrogridLine<ScalarT, IdxT>::~MicrogridLine()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Evaluate residual of microgrid line
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    f_int_[0] = -yp_int_[0] - (R_ / L_) * y_int_[0] + *y_ext_[0] * y_int_[1] + (*y_ext_[1] - *y_ext_[3]) / L_;
-    f_int_[1] = -yp_int_[1] - (R_ / L_) * y_int_[1] - *y_ext_[0] * y_int_[0] + (*y_ext_[2] - *y_ext_[4]) / L_;
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // Port 1
-    *f_ext_[1] += -y_int_[0];
-    *f_ext_[2] += -y_int_[1];
-
-    // Port 2
-    *f_ext_[3] += y_int_[0];
-    *f_ext_[4] += y_int_[1];
-
-    return 0;
-  }
-
-  /**
-   * @brief Generate Jacobian for Microgrid Line
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
-
-    // Create dF/dy
-    std::vector<IdxT>  rtemp{1, 2, 3, 4};
-    std::vector<IdxT>  ctemp{5, 6, 5, 6};
-    std::vector<RealT> valtemp{-1.0, -1.0, 1.0, 1.0};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    std::vector<IdxT> ccord{0, 1, 3, 5, 6};
-
-    std::vector<IdxT>  rcord(ccord.size(), 5);
-    std::vector<RealT> vals{};
-    vals = {static_cast<RealT>(y_int_[1]), (1.0 / L_), -(1.0 / L_), -(R_ / L_) - alpha_, static_cast<RealT>(*y_ext_[0])};
-    this->setJacValues(rcord, ccord, vals);
-
-    std::vector<IdxT> ccor2{0, 2, 4, 5, 6};
-    std::fill(rcord.begin(), rcord.end(), 6);
-    vals = {-static_cast<RealT>(y_int_[0]), (1.0 / L_), -(1.0 / L_), -static_cast<RealT>(*y_ext_[0]), -(R_ / L_) - alpha_};
-    this->setJacValues(rcord, ccor2, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::allocate()
-  {
-    CircuitComponent<ScalarT, IdxT>::allocate();
-
-    this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
-    this->setExternalConnectionNodes(1, bus1_->getNodeConnection(0));
-    this->setExternalConnectionNodes(2, bus1_->getNodeConnection(1));
-    this->setExternalConnectionNodes(3, bus2_->getNodeConnection(0));
-    this->setExternalConnectionNodes(4, bus2_->getNodeConnection(1));
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::initializeAdjoint()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLine<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* MicrogridLine<ScalarT, IdxT>::clone() const
-  {
-    return new MicrogridLine<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class MicrogridLine<double, long int>;
-  template class MicrogridLine<double, size_t>;
-  template class MicrogridLine<DependencyTracking::Variable, long int>;
-  template class MicrogridLine<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a constant MicrogridLine model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     *
+     *
+     * Model is from paper: "Modeling, Analysis and Testing of Autonomous Operation
+     * of an Inverter-Based Microgrid", Nagaraju Pogaku, Milan Prodanovic, and
+     * Timothy C. Green, Section C
+     *
+     * @todo Consider having \omegaref as a global constant, not a node variable.
+     */
+    template <class ScalarT, typename IdxT>
+    MicrogridLine<ScalarT, IdxT>::MicrogridLine(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* bus1, NodeT* bus2)
+      : R_(R),
+        L_(L),
+        node_ref_(node_ref),
+        bus1_(bus1),
+        bus2_(bus2)
+    {
+      assert(node_ref_->size() == 1);
+      assert(bus1_->size() == 2);
+      assert(bus2_->size() == 2);
+      // internals [id, iq]
+      // externals [\omegaref, vbd_in, vbq_in, vbd_out, vbq_out]
+      size_           = 7;
+      n_intern_       = 2;
+      n_extern_       = 5;
+      extern_indices_ = {0, 1, 2, 3, 4};
+      idc_            = id;
+      nnz_            = 14;
+    }
+
+    template <class ScalarT, typename IdxT>
+    MicrogridLine<ScalarT, IdxT>::~MicrogridLine()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Evaluate residual of microgrid line
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      f_int_[0] = -yp_int_[0] - (R_ / L_) * y_int_[0] + *y_ext_[0] * y_int_[1] + (*y_ext_[1] - *y_ext_[3]) / L_;
+      f_int_[1] = -yp_int_[1] - (R_ / L_) * y_int_[1] - *y_ext_[0] * y_int_[0] + (*y_ext_[2] - *y_ext_[4]) / L_;
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // Port 1
+      *f_ext_[1] += -y_int_[0];
+      *f_ext_[2] += -y_int_[1];
+
+      // Port 2
+      *f_ext_[3] += y_int_[0];
+      *f_ext_[4] += y_int_[1];
+
+      return 0;
+    }
+
+    /**
+     * @brief Generate Jacobian for Microgrid Line
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      // Create dF/dy
+      std::vector<IdxT>  rtemp{1, 2, 3, 4};
+      std::vector<IdxT>  ctemp{5, 6, 5, 6};
+      std::vector<RealT> valtemp{-1.0, -1.0, 1.0, 1.0};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      std::vector<IdxT> ccord{0, 1, 3, 5, 6};
+
+      std::vector<IdxT>  rcord(ccord.size(), 5);
+      std::vector<RealT> vals{};
+      vals = {static_cast<RealT>(y_int_[1]), (1.0 / L_), -(1.0 / L_), -(R_ / L_) - alpha_, static_cast<RealT>(*y_ext_[0])};
+      this->setJacValues(rcord, ccord, vals);
+
+      std::vector<IdxT> ccor2{0, 2, 4, 5, 6};
+      std::fill(rcord.begin(), rcord.end(), 6);
+      vals = {-static_cast<RealT>(y_int_[0]), (1.0 / L_), -(1.0 / L_), -static_cast<RealT>(*y_ext_[0]), -(R_ / L_) - alpha_};
+      this->setJacValues(rcord, ccor2, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::allocate()
+    {
+      CircuitComponent<ScalarT, IdxT>::allocate();
+
+      this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
+      this->setExternalConnectionNodes(1, bus1_->getNodeConnection(0));
+      this->setExternalConnectionNodes(2, bus1_->getNodeConnection(1));
+      this->setExternalConnectionNodes(3, bus2_->getNodeConnection(0));
+      this->setExternalConnectionNodes(4, bus2_->getNodeConnection(1));
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLine<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* MicrogridLine<ScalarT, IdxT>::clone() const
+    {
+      return new MicrogridLine<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class MicrogridLine<double, long int>;
+    template class MicrogridLine<double, size_t>;
+    template class MicrogridLine<DependencyTracking::Variable, long int>;
+    template class MicrogridLine<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp
index 0749e5ceb..38fcc81ab 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -7,71 +6,68 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a MicrogridLine class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class MicrogridLine : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
+    /*!
+     * @brief Declaration of a MicrogridLine class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class MicrogridLine : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    MicrogridLine(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* bus1, NodeT* bus2);
-    virtual ~MicrogridLine();
+    public:
+      MicrogridLine(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* bus1, NodeT* bus2);
+      virtual ~MicrogridLine();
 
-    int initialize();
-    int allocate() final;
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int allocate() final;
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT  R_;
-    RealT  L_;
-    NodeT* node_ref_;
-    NodeT* bus1_;
-    NodeT* bus2_;
-  };
+    private:
+      RealT  R_;
+      RealT  L_;
+      NodeT* node_ref_;
+      NodeT* bus1_;
+      NodeT* bus2_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp
index 34de349d1..2fed49932 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp
@@ -7,184 +7,185 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a constant MicrogridLoad model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   *
-   *
-   * Model is from paper: "
-      "Modeling, Analysis and Testing of Autonomous Operation of an Inverter-Based Microgrid" Nagaraju Pogaku, Milan Prodanovic, and Timothy C. Green"
-   * Section D
-   */
-
-  template <class ScalarT, typename IdxT>
-  MicrogridLoad<ScalarT, IdxT>::MicrogridLoad(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* node_bus)
-    : R_(R),
-      L_(L),
-      node_ref_(node_ref),
-      node_bus_(node_bus)
-  {
-    assert(node_ref_->size() == 1);
-    assert(node_bus_->size() == 2);
-    // internals [id, iq]
-    // externals [\omegaref, vbd_out, vbq_out]
-    size_           = 5;
-    n_intern_       = 2;
-    n_extern_       = 3;
-    extern_indices_ = {0, 1, 2};
-    idc_            = id;
-    nnz_            = 10;
-  }
-
-  template <class ScalarT, typename IdxT>
-  MicrogridLoad<ScalarT, IdxT>::~MicrogridLoad()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Eval Micro Load
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    f_int_[0] = -yp_int_[0] - (R_ / L_) * y_int_[0] + *y_ext_[0] * y_int_[1] + *y_ext_[1] / L_;
-    f_int_[1] = -yp_int_[1] - (R_ / L_) * y_int_[1] - *y_ext_[0] * y_int_[0] + *y_ext_[2] / L_;
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // only input for loads
-
-    // input
-    *f_ext_[1] += -y_int_[0];
-    *f_ext_[2] += -y_int_[1];
-
-    return 0;
-  }
-
-  /**
-   * @brief Generate Jacobian for Micro Load
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
-
-    // Create dF/dy
-    std::vector<IdxT>  rtemp{1, 2};
-    std::vector<IdxT>  ctemp{3, 4};
-    std::vector<RealT> valtemp{-1.0, -1.0};
-    this->setJacValues(rtemp, ctemp, valtemp);
-
-    std::vector<IdxT> ccord{0, 1, 3, 4};
-
-    std::vector<IdxT>  rcord(ccord.size(), 3);
-    std::vector<RealT> vals{};
-    vals = {static_cast<RealT>(y_int_[1]), (1.0 / L_), -(R_ / L_) - alpha_, static_cast<RealT>(*y_ext_[0])};
-    this->setJacValues(rcord, ccord, vals);
-
-    std::vector<IdxT> ccor2{0, 2, 3, 4};
-    std::fill(rcord.begin(), rcord.end(), 4);
-    vals = {-static_cast<RealT>(y_int_[0]), (1.0 / L_), -static_cast<RealT>(*y_ext_[0]), -(R_ / L_) - alpha_};
-    this->setJacValues(rcord, ccor2, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::allocate()
-  {
-    CircuitComponent<ScalarT, IdxT>::allocate();
-
-    this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
-    this->setExternalConnectionNodes(1, node_bus_->getNodeConnection(0));
-    this->setExternalConnectionNodes(2, node_bus_->getNodeConnection(1));
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::initializeAdjoint()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int MicrogridLoad<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* MicrogridLoad<ScalarT, IdxT>::clone() const
-  {
-    return new MicrogridLoad<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class MicrogridLoad<double, long int>;
-  template class MicrogridLoad<double, size_t>;
-  template class MicrogridLoad<DependencyTracking::Variable, long int>;
-  template class MicrogridLoad<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a constant MicrogridLoad model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     *
+     *
+     * Model is from paper: "
+        "Modeling, Analysis and Testing of Autonomous Operation of an Inverter-Based Microgrid" Nagaraju Pogaku, Milan Prodanovic, and Timothy C. Green"
+     * Section D
+     */
+    template <class ScalarT, typename IdxT>
+    MicrogridLoad<ScalarT, IdxT>::MicrogridLoad(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* node_bus)
+      : R_(R),
+        L_(L),
+        node_ref_(node_ref),
+        node_bus_(node_bus)
+    {
+      assert(node_ref_->size() == 1);
+      assert(node_bus_->size() == 2);
+      // internals [id, iq]
+      // externals [\omegaref, vbd_out, vbq_out]
+      size_           = 5;
+      n_intern_       = 2;
+      n_extern_       = 3;
+      extern_indices_ = {0, 1, 2};
+      idc_            = id;
+      nnz_            = 10;
+    }
+
+    template <class ScalarT, typename IdxT>
+    MicrogridLoad<ScalarT, IdxT>::~MicrogridLoad()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Eval Micro Load
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      f_int_[0] = -yp_int_[0] - (R_ / L_) * y_int_[0] + *y_ext_[0] * y_int_[1] + *y_ext_[1] / L_;
+      f_int_[1] = -yp_int_[1] - (R_ / L_) * y_int_[1] - *y_ext_[0] * y_int_[0] + *y_ext_[2] / L_;
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // only input for loads
+
+      // input
+      *f_ext_[1] += -y_int_[0];
+      *f_ext_[2] += -y_int_[1];
+
+      return 0;
+    }
+
+    /**
+     * @brief Generate Jacobian for Micro Load
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      // Create dF/dy
+      std::vector<IdxT>  rtemp{1, 2};
+      std::vector<IdxT>  ctemp{3, 4};
+      std::vector<RealT> valtemp{-1.0, -1.0};
+      this->setJacValues(rtemp, ctemp, valtemp);
+
+      std::vector<IdxT> ccord{0, 1, 3, 4};
+
+      std::vector<IdxT>  rcord(ccord.size(), 3);
+      std::vector<RealT> vals{};
+      vals = {static_cast<RealT>(y_int_[1]), (1.0 / L_), -(R_ / L_) - alpha_, static_cast<RealT>(*y_ext_[0])};
+      this->setJacValues(rcord, ccord, vals);
+
+      std::vector<IdxT> ccor2{0, 2, 3, 4};
+      std::fill(rcord.begin(), rcord.end(), 4);
+      vals = {-static_cast<RealT>(y_int_[0]), (1.0 / L_), -static_cast<RealT>(*y_ext_[0]), -(R_ / L_) - alpha_};
+      this->setJacValues(rcord, ccor2, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::allocate()
+    {
+      CircuitComponent<ScalarT, IdxT>::allocate();
+
+      this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
+      this->setExternalConnectionNodes(1, node_bus_->getNodeConnection(0));
+      this->setExternalConnectionNodes(2, node_bus_->getNodeConnection(1));
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int MicrogridLoad<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* MicrogridLoad<ScalarT, IdxT>::clone() const
+    {
+      return new MicrogridLoad<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class MicrogridLoad<double, long int>;
+    template class MicrogridLoad<double, size_t>;
+    template class MicrogridLoad<DependencyTracking::Variable, long int>;
+    template class MicrogridLoad<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp
index 12935d671..c36468004 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -7,70 +6,67 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a passive MicrogridLoad class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class MicrogridLoad : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
+    /*!
+     * @brief Declaration of a passive MicrogridLoad class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class MicrogridLoad : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    MicrogridLoad(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* node_bus);
-    virtual ~MicrogridLoad();
+    public:
+      MicrogridLoad(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* node_bus);
+      virtual ~MicrogridLoad();
 
-    int initialize();
-    int allocate() final;
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int allocate() final;
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT  R_;
-    RealT  L_;
-    NodeT* node_ref_;
-    NodeT* node_bus_;
-  };
+    private:
+      RealT  R_;
+      RealT  L_;
+      NodeT* node_ref_;
+      NodeT* node_bus_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp b/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp
index 75b3ec18b..b4d0c24a9 100644
--- a/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp
+++ b/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp
@@ -1,5 +1,4 @@
 
-
 #include "Resistor.hpp"
 
 #include <cmath>
@@ -8,147 +7,148 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a resistor model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   */
-
-  template <class ScalarT, typename IdxT>
-  Resistor<ScalarT, IdxT>::Resistor(IdxT id, RealT R, NodeT* node1, NodeT* node2)
-    : R_(R), node1_(node1), node2_(node2)
-  {
-    assert(node1_->size() == 1);
-    assert(node2_->size() == 1);
-    size_           = 2;
-    n_intern_       = 0;
-    n_extern_       = 2;
-    extern_indices_ = {0, 1};
-    idc_            = id;
-    nnz_            = 4;
-  }
-
-  template <class ScalarT, typename IdxT>
-  Resistor<ScalarT, IdxT>::~Resistor()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /// There are no internal variables in this component, so \ref tag_ can be set arbitrarily.
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::tagDifferentiable()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Computes the resistors resisdual
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // input
-    *f_ext_[0] += (*y_ext_[0] - *y_ext_[1]) / R_;
-    // ouput
-    *f_ext_[1] += (*y_ext_[1] - *y_ext_[0]) / R_;
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
-
-    // Create dF/dy
-    // does compiler make constant???
-    std::vector<IdxT>  rcord{0, 0, 1, 1};
-    std::vector<IdxT>  ccord{0, 1, 0, 1};
-    std::vector<RealT> vals{1.0 / R_, -1.0 / R_, -1.0 / R_, 1.0 / R_};
-    this->setJacValues(rcord, ccord, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::allocate()
-  {
-    CircuitComponent<ScalarT, IdxT>::allocate();
-
-    this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
-    this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int Resistor<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* Resistor<ScalarT, IdxT>::clone() const
-  {
-    return new Resistor<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class Resistor<double, long int>;
-  template class Resistor<double, size_t>;
-  template class Resistor<DependencyTracking::Variable, long int>;
-  template class Resistor<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a resistor model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     */
+    template <class ScalarT, typename IdxT>
+    Resistor<ScalarT, IdxT>::Resistor(IdxT id, RealT R, NodeT* node1, NodeT* node2)
+      : R_(R), node1_(node1), node2_(node2)
+    {
+      assert(node1_->size() == 1);
+      assert(node2_->size() == 1);
+      size_           = 2;
+      n_intern_       = 0;
+      n_extern_       = 2;
+      extern_indices_ = {0, 1};
+      idc_            = id;
+      nnz_            = 4;
+    }
+
+    template <class ScalarT, typename IdxT>
+    Resistor<ScalarT, IdxT>::~Resistor()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /// There are no internal variables in this component, so \ref tag_ can be set arbitrarily.
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::tagDifferentiable()
+    {
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Computes the resistors resisdual
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // input
+      *f_ext_[0] += (*y_ext_[0] - *y_ext_[1]) / R_;
+      // ouput
+      *f_ext_[1] += (*y_ext_[1] - *y_ext_[0]) / R_;
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      // Create dF/dy
+      // does compiler make constant???
+      std::vector<IdxT>  rcord{0, 0, 1, 1};
+      std::vector<IdxT>  ccord{0, 1, 0, 1};
+      std::vector<RealT> vals{1.0 / R_, -1.0 / R_, -1.0 / R_, 1.0 / R_};
+      this->setJacValues(rcord, ccord, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::allocate()
+    {
+      CircuitComponent<ScalarT, IdxT>::allocate();
+
+      this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
+      this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int Resistor<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* Resistor<ScalarT, IdxT>::clone() const
+    {
+      return new Resistor<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class Resistor<double, long int>;
+    template class Resistor<double, size_t>;
+    template class Resistor<DependencyTracking::Variable, long int>;
+    template class Resistor<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp b/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp
index 354074bc9..19a8600a8 100644
--- a/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp
+++ b/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -7,69 +6,66 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a Resistor class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class Resistor : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
+    /*!
+     * @brief Declaration of a Resistor class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class Resistor : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    Resistor(IdxT id, RealT R, NodeT* node1, NodeT* node2);
-    virtual ~Resistor();
+    public:
+      Resistor(IdxT id, RealT R, NodeT* node1, NodeT* node2);
+      virtual ~Resistor();
 
-    int initialize();
-    int allocate() final;
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int allocate() final;
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT  R_;
-    NodeT* node1_;
-    NodeT* node2_;
-  };
+    private:
+      RealT  R_;
+      NodeT* node1_;
+      NodeT* node2_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp
index 0616977e2..7497a9d06 100644
--- a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp
+++ b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp
@@ -7,193 +7,194 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a constant SynchronousMachine model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   * @todo This model's equations are not finished
-   * @todo needs to be tested for correctness
-   *
-   * @tparam ScalarT - floating point type for the model
-   * @tparam IdxT - integer index type for the model
-   *
-   * @param[in] id - unique identifier for the component
-   * @param[in] Lls - stator leakage inductance
-   * @param[in] Llkq - tuple of damper leakage reactances
-   * @param[in] Llfd - field leakage reactance
-   * @param[in] Llkd - damper leakage reactance
-   * @param[in] Lmq - quadrature axis magnetizing reactance
-   * @param[in] Lmd - direct axis magnetizing reactance
-   * @param[in] Rs - stator resistance
-   * @param[in] Rkq - tuple of damper resistances
-   * @param[in] Rfd - field resistance
-   * @param[in] Rkd - damper resistance
-   * @param[in] RJ - rotor moment of inertia
-   * @param[in] P - number of poles
-   * @param[in] mub - rated frequency
-   */
-
-  template <class ScalarT, typename IdxT>
-  SynchronousMachine<ScalarT, IdxT>::SynchronousMachine(IdxT id, RealT Lls, std::tuple<RealT, RealT> Llkq, RealT Llfd, RealT Llkd, RealT Lmq, RealT Lmd, RealT Rs, std::tuple<RealT, RealT> Rkq, RealT Rfd, RealT Rkd, RealT RJ, RealT P, RealT mub)
-    : Lls_(Lls),
-      Llkq_(Llkq),
-      Llfd_(Llfd),
-      Llkd_(Llkd),
-      Lmq_(Lmq),
-      Lmd_(Lmd),
-      Rs_(Rs),
-      Rkq_(Rkq),
-      Rfd_(Rfd),
-      Rkd_(Rkd),
-      RJ_(RJ),
-      P_(P),
-      mub_(mub)
-  {
-    size_           = 13;
-    n_intern_       = 6;
-    n_extern_       = 7;
-    extern_indices_ = {0, 1, 2, 3, 4};
-    idc_            = id;
-  }
-
-  template <class ScalarT, typename IdxT>
-  SynchronousMachine<ScalarT, IdxT>::~SynchronousMachine()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are differentials
-    std::fill(tag_.begin(), tag_.end(), true);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Compute the resisdual of the component.
-   *
-   * @todo not finished
-   */
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    ScalarT                  rkq1  = static_cast<ScalarT>(std::get<0>(Rkq_));
-    [[maybe_unused]] ScalarT rkq2  = static_cast<ScalarT>(std::get<1>(Rkq_));
-    ScalarT                  llkq1 = static_cast<ScalarT>(std::get<0>(Llkq_));
-    [[maybe_unused]] ScalarT llkq2 = static_cast<ScalarT>(std::get<1>(Llkq_));
-
-    static constexpr auto pi = std::numbers::pi_v<RealT>;
-
-    ScalarT cos1   = std::cos((P_ / 2.0) * y_int_[0]);
-    ScalarT sin1   = std::sin((P_ / 2.0) * y_int_[0]);
-    ScalarT cos23m = std::cos((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
-    ScalarT sin23m = std::sin((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
-    ScalarT cos23p = std::cos((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
-    ScalarT sin23p = std::sin((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
-
-    f_int_[0] = (-2.0 / 3.0) * (*y_ext_[0] * cos1 + *y_ext_[1] * cos23m + *y_ext_[2] * cos23p) + Rs_ * y_int_[1] + (Lls_ + Lmq_) * yp_int_[1] + Lmq_ * yp_int_[4] + Lmq_ * yp_int_[5] + *y_ext_[4] * (P_ / 2.0) * ((Lls_ + Lmd_) * y_int_[2] + Lmd_ * y_int_[6] + Lmd_ * y_int_[7]);
-    f_int_[1] = (-2.0 / 3.0) * (*y_ext_[0] * sin1 - *y_ext_[1] * sin23m - *y_ext_[2] * sin23p) + Rs_ * y_int_[2] + (Lls_ + Lmd_) * yp_int_[2] + Lmd_ * yp_int_[6] + Lmd_ * yp_int_[7] - *y_ext_[4] * (P_ / 2.0) * ((Lls_ + Lmq_) * y_int_[1] + Lmq_ * y_int_[4] + Lmq_ * y_int_[5]);
-    f_int_[2] = (-1.0 / 3.0) * (*y_ext_[0] + *y_ext_[1] + *y_ext_[2]) + Rs_ * y_int_[3] + Lls_ * yp_int_[3];
-    f_int_[3] = rkq1 * y_int_[4] + (llkq1 + Lmq_) * yp_int_[4] + Lmq_ * yp_int_[1] + Lmq_ * yp_int_[5];
-    f_int_[4] = rkq1 * y_int_[4] + (llkq1 + Lmq_) * yp_int_[4] + Lmq_ * yp_int_[1] + Lmq_ * yp_int_[5];
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    [[maybe_unused]] ScalarT rkq2  = static_cast<ScalarT>(std::get<1>(Rkq_));
-    [[maybe_unused]] ScalarT llkq2 = static_cast<ScalarT>(std::get<1>(Llkq_));
-
-    static constexpr auto pi = std::numbers::pi_v<RealT>;
-
-    ScalarT cos1   = std::cos((P_ / 2.0) * y_int_[0]);
-    ScalarT sin1   = std::sin((P_ / 2.0) * y_int_[0]);
-    ScalarT cos23m = std::cos((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
-    ScalarT sin23m = std::sin((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
-    ScalarT cos23p = std::cos((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
-    ScalarT sin23p = std::sin((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
-
-    *f_ext_[0] += y_int_[1] * cos1 + y_int_[2] * sin1 + y_int_[3];
-    *f_ext_[1] += y_int_[1] * cos23m + y_int_[2] * sin23m + y_int_[3];
-    *f_ext_[2] += y_int_[1] * cos23p + y_int_[2] * sin23p + y_int_[3];
-    *f_ext_[3] += RJ_ * *yp_ext_[4] - (3.0 / 4.0) * P_ * (Lmd_ * y_int_[1] * (y_int_[2] + y_int_[6] + y_int_[7]) - Lmq_ * y_int_[2] * (y_int_[1] + y_int_[4] + *y_ext_[0]));
-    *f_ext_[4] += yp_int_[0] - *y_ext_[4];
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::evaluateJacobian()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::evaluateIntegrand()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int SynchronousMachine<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* SynchronousMachine<ScalarT, IdxT>::clone() const
-  {
-    return new SynchronousMachine<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class SynchronousMachine<double, long int>;
-  template class SynchronousMachine<double, size_t>;
-  template class SynchronousMachine<DependencyTracking::Variable, long int>;
-  template class SynchronousMachine<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a constant SynchronousMachine model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     * @todo This model's equations are not finished
+     * @todo needs to be tested for correctness
+     *
+     * @tparam ScalarT - floating point type for the model
+     * @tparam IdxT - integer index type for the model
+     *
+     * @param[in] id - unique identifier for the component
+     * @param[in] Lls - stator leakage inductance
+     * @param[in] Llkq - tuple of damper leakage reactances
+     * @param[in] Llfd - field leakage reactance
+     * @param[in] Llkd - damper leakage reactance
+     * @param[in] Lmq - quadrature axis magnetizing reactance
+     * @param[in] Lmd - direct axis magnetizing reactance
+     * @param[in] Rs - stator resistance
+     * @param[in] Rkq - tuple of damper resistances
+     * @param[in] Rfd - field resistance
+     * @param[in] Rkd - damper resistance
+     * @param[in] RJ - rotor moment of inertia
+     * @param[in] P - number of poles
+     * @param[in] mub - rated frequency
+     */
+    template <class ScalarT, typename IdxT>
+    SynchronousMachine<ScalarT, IdxT>::SynchronousMachine(IdxT id, RealT Lls, std::tuple<RealT, RealT> Llkq, RealT Llfd, RealT Llkd, RealT Lmq, RealT Lmd, RealT Rs, std::tuple<RealT, RealT> Rkq, RealT Rfd, RealT Rkd, RealT RJ, RealT P, RealT mub)
+      : Lls_(Lls),
+        Llkq_(Llkq),
+        Llfd_(Llfd),
+        Llkd_(Llkd),
+        Lmq_(Lmq),
+        Lmd_(Lmd),
+        Rs_(Rs),
+        Rkq_(Rkq),
+        Rfd_(Rfd),
+        Rkd_(Rkd),
+        RJ_(RJ),
+        P_(P),
+        mub_(mub)
+    {
+      size_           = 13;
+      n_intern_       = 6;
+      n_extern_       = 7;
+      extern_indices_ = {0, 1, 2, 3, 4};
+      idc_            = id;
+    }
+
+    template <class ScalarT, typename IdxT>
+    SynchronousMachine<ScalarT, IdxT>::~SynchronousMachine()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are differentials
+      std::fill(tag_.begin(), tag_.end(), true);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Compute the resisdual of the component.
+     *
+     * @todo not finished
+     */
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      ScalarT                  rkq1  = static_cast<ScalarT>(std::get<0>(Rkq_));
+      [[maybe_unused]] ScalarT rkq2  = static_cast<ScalarT>(std::get<1>(Rkq_));
+      ScalarT                  llkq1 = static_cast<ScalarT>(std::get<0>(Llkq_));
+      [[maybe_unused]] ScalarT llkq2 = static_cast<ScalarT>(std::get<1>(Llkq_));
+
+      static constexpr auto pi = std::numbers::pi_v<RealT>;
+
+      ScalarT cos1   = std::cos((P_ / 2.0) * y_int_[0]);
+      ScalarT sin1   = std::sin((P_ / 2.0) * y_int_[0]);
+      ScalarT cos23m = std::cos((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
+      ScalarT sin23m = std::sin((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
+      ScalarT cos23p = std::cos((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
+      ScalarT sin23p = std::sin((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
+
+      f_int_[0] = (-2.0 / 3.0) * (*y_ext_[0] * cos1 + *y_ext_[1] * cos23m + *y_ext_[2] * cos23p) + Rs_ * y_int_[1] + (Lls_ + Lmq_) * yp_int_[1] + Lmq_ * yp_int_[4] + Lmq_ * yp_int_[5] + *y_ext_[4] * (P_ / 2.0) * ((Lls_ + Lmd_) * y_int_[2] + Lmd_ * y_int_[6] + Lmd_ * y_int_[7]);
+      f_int_[1] = (-2.0 / 3.0) * (*y_ext_[0] * sin1 - *y_ext_[1] * sin23m - *y_ext_[2] * sin23p) + Rs_ * y_int_[2] + (Lls_ + Lmd_) * yp_int_[2] + Lmd_ * yp_int_[6] + Lmd_ * yp_int_[7] - *y_ext_[4] * (P_ / 2.0) * ((Lls_ + Lmq_) * y_int_[1] + Lmq_ * y_int_[4] + Lmq_ * y_int_[5]);
+      f_int_[2] = (-1.0 / 3.0) * (*y_ext_[0] + *y_ext_[1] + *y_ext_[2]) + Rs_ * y_int_[3] + Lls_ * yp_int_[3];
+      f_int_[3] = rkq1 * y_int_[4] + (llkq1 + Lmq_) * yp_int_[4] + Lmq_ * yp_int_[1] + Lmq_ * yp_int_[5];
+      f_int_[4] = rkq1 * y_int_[4] + (llkq1 + Lmq_) * yp_int_[4] + Lmq_ * yp_int_[1] + Lmq_ * yp_int_[5];
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      [[maybe_unused]] ScalarT rkq2  = static_cast<ScalarT>(std::get<1>(Rkq_));
+      [[maybe_unused]] ScalarT llkq2 = static_cast<ScalarT>(std::get<1>(Llkq_));
+
+      static constexpr auto pi = std::numbers::pi_v<RealT>;
+
+      ScalarT cos1   = std::cos((P_ / 2.0) * y_int_[0]);
+      ScalarT sin1   = std::sin((P_ / 2.0) * y_int_[0]);
+      ScalarT cos23m = std::cos((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
+      ScalarT sin23m = std::sin((P_ / 2.0) * y_int_[0] - (2.0 / 3.0) * pi);
+      ScalarT cos23p = std::cos((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
+      ScalarT sin23p = std::sin((P_ / 2.0) * y_int_[0] + (2.0 / 3.0) * pi);
+
+      *f_ext_[0] += y_int_[1] * cos1 + y_int_[2] * sin1 + y_int_[3];
+      *f_ext_[1] += y_int_[1] * cos23m + y_int_[2] * sin23m + y_int_[3];
+      *f_ext_[2] += y_int_[1] * cos23p + y_int_[2] * sin23p + y_int_[3];
+      *f_ext_[3] += RJ_ * *yp_ext_[4] - (3.0 / 4.0) * P_ * (Lmd_ * y_int_[1] * (y_int_[2] + y_int_[6] + y_int_[7]) - Lmq_ * y_int_[2] * (y_int_[1] + y_int_[4] + *y_ext_[0]));
+      *f_ext_[4] += yp_int_[0] - *y_ext_[4];
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::evaluateJacobian()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int SynchronousMachine<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* SynchronousMachine<ScalarT, IdxT>::clone() const
+    {
+      return new SynchronousMachine<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class SynchronousMachine<double, long int>;
+    template class SynchronousMachine<double, size_t>;
+    template class SynchronousMachine<DependencyTracking::Variable, long int>;
+    template class SynchronousMachine<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp
index 55356f191..771364cbf 100644
--- a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp
+++ b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <tuple>
@@ -8,77 +7,74 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a SynchronousMachine class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class SynchronousMachine : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+    /*!
+     * @brief Declaration of a SynchronousMachine class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class SynchronousMachine : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    SynchronousMachine(IdxT id, RealT Lls, std::tuple<RealT, RealT> Llkq, RealT Llfd, RealT Llkd, RealT Lmq, RealT Lmd, RealT Rs, std::tuple<RealT, RealT> Rkq, RealT Rfd, RealT Rkd, RealT RJ, RealT P, RealT mub);
-    virtual ~SynchronousMachine();
+    public:
+      SynchronousMachine(IdxT id, RealT Lls, std::tuple<RealT, RealT> Llkq, RealT Llfd, RealT Llkd, RealT Lmq, RealT Lmd, RealT Rs, std::tuple<RealT, RealT> Rkq, RealT Rfd, RealT Rkd, RealT RJ, RealT P, RealT mub);
+      virtual ~SynchronousMachine();
 
-    int initialize();
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT                    Lls_;
-    std::tuple<RealT, RealT> Llkq_;
-    RealT                    Llfd_;
-    RealT                    Llkd_;
-    RealT                    Lmq_;
-    RealT                    Lmd_;
-    RealT                    Rs_;
-    std::tuple<RealT, RealT> Rkq_;
-    RealT                    Rfd_;
-    RealT                    Rkd_;
-    RealT                    RJ_;
-    RealT                    P_;
-    RealT                    mub_;
-  };
+    private:
+      RealT                    Lls_;
+      std::tuple<RealT, RealT> Llkq_;
+      RealT                    Llfd_;
+      RealT                    Llkd_;
+      RealT                    Lmq_;
+      RealT                    Lmd_;
+      RealT                    Rs_;
+      std::tuple<RealT, RealT> Rkq_;
+      RealT                    Rfd_;
+      RealT                    Rkd_;
+      RealT                    RJ_;
+      RealT                    P_;
+      RealT                    mub_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp b/GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp
index 51c8dcee1..8cc3c1402 100644
--- a/GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp
+++ b/GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <algorithm>
@@ -14,518 +13,520 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class PowerElectronicsModel : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT          = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using CsrMatrixT     = typename CircuitComponent<ScalarT, IdxT>::CsrMatrixT;
-    using component_type = CircuitComponent<ScalarT, IdxT>;
-    using node_type      = PowerElectronics::NodeBase<ScalarT, IdxT>;
-
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::allocated_;
-    using CircuitComponent<ScalarT, IdxT>::allocateVectors;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-
-  public:
-    /**
-     * @brief Default constructor for the system model
-     *
-     * @post System model parameters set as default
-     */
-    PowerElectronicsModel()
-    {
-      // By default don't use the jacobian
-      use_jac_ = false;
-    }
-
-    /**
-     * @brief Constructor for the system model
-     *
-     * @param[in] use_jac Boolean to choose if to use jacobian
-     *
-     * @post System model parameters set as input
-     */
-    PowerElectronicsModel(bool use_jac = false)
-    {
-      // Can choose if to use jacobian
-      use_jac_ = use_jac;
-    }
-
-    /**
-     * @brief Destructor for the system model
-     *
-     * @pre System components are allocated
-     *
-     * @post System components are deallocated
-     *
-     */
-    virtual ~PowerElectronicsModel()
+    template <class ScalarT, typename IdxT>
+    class PowerElectronicsModel : public CircuitComponent<ScalarT, IdxT>
     {
-      for (auto comp : this->components_)
+      using RealT          = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using CsrMatrixT     = typename CircuitComponent<ScalarT, IdxT>::CsrMatrixT;
+      using component_type = CircuitComponent<ScalarT, IdxT>;
+      using node_type      = PowerElectronics::NodeBase<ScalarT, IdxT>;
+
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::allocated_;
+      using CircuitComponent<ScalarT, IdxT>::allocateVectors;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+
+    public:
+      /**
+       * @brief Default constructor for the system model
+       *
+       * @post System model parameters set as default
+       */
+      PowerElectronicsModel()
       {
-        delete comp;
+        // By default don't use the jacobian
+        use_jac_ = false;
       }
-      delete csr_jac_;
-      delete[] map_to_csr_;
-    }
-
-    /**
-     * @brief Will check if each component has jacobian avalible. If one doesn't have it, return false.
-     *
-     *
-     * @return true if all components have jacobian
-     * @return false otherwise
-     */
-    bool hasJacobian() final
-    {
-      if (!this->use_jac_)
-        return false;
 
-      for (const auto& component : components_)
+      /**
+       * @brief Constructor for the system model
+       *
+       * @param[in] use_jac Boolean to choose if to use jacobian
+       *
+       * @post System model parameters set as input
+       */
+      PowerElectronicsModel(bool use_jac = false)
       {
-        if (!component->hasJacobian())
-        {
-          return false;
-        }
+        // Can choose if to use jacobian
+        use_jac_ = use_jac;
       }
-      return true;
-    }
-
-    /**
-     * @brief Allocate system vectors and construct the system CSR Jacobian
-     *
-     * @post System model vectors allocated with the computed total number of unknowns
-     * @post CSR Jacobian sparsity pattern is computed
-     * @post COO->CSR mapping is computed
-     * @post Every component's \ref CircuitComponent::y_int_, \ref CircuitComponent::yp_int_, and \ref CircuitComponent::f_int_ pointers
-     * are set to their appropriate offsets in the system vector, allowing them to directly access their internal variables, derivatives,
-     * and residuals.
-     *
-     * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
-     */
-    int allocate() final
-    {
-      size_t component_internal_size = 0;
-      for (component_type* comp : components_)
+
+      /**
+       * @brief Destructor for the system model
+       *
+       * @pre System components are allocated
+       *
+       * @post System components are deallocated
+       *
+       */
+      virtual ~PowerElectronicsModel()
       {
-        component_internal_size += comp->getInternalSize();
+        for (auto comp : this->components_)
+        {
+          delete comp;
+        }
+        delete csr_jac_;
+        delete[] map_to_csr_;
       }
 
-      size_t node_internal_size = 0;
-      for (node_type* node : nodes_)
+      /**
+       * @brief Will check if each component has jacobian avalible. If one doesn't have it, return false.
+       *
+       *
+       * @return true if all components have jacobian
+       * @return false otherwise
+       */
+      bool hasJacobian() final
       {
-        node_internal_size += node->getInternalSize();
+        if (!this->use_jac_)
+          return false;
+
+        for (const auto& component : components_)
+        {
+          if (!component->hasJacobian())
+          {
+            return false;
+          }
+        }
+        return true;
       }
 
-      n_intern_ = component_internal_size + node_internal_size;
-      n_extern_ = 0;
-      size_     = n_intern_ + n_extern_;
+      /**
+       * @brief Allocate system vectors and construct the system CSR Jacobian
+       *
+       * @post System model vectors allocated with the computed total number of unknowns
+       * @post CSR Jacobian sparsity pattern is computed
+       * @post COO->CSR mapping is computed
+       * @post Every component's \ref CircuitComponent::y_int_, \ref CircuitComponent::yp_int_, and \ref CircuitComponent::f_int_ pointers
+       * are set to their appropriate offsets in the system vector, allowing them to directly access their internal variables, derivatives,
+       * and residuals.
+       *
+       * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
+       */
+      int allocate() final
+      {
+        size_t component_internal_size = 0;
+        for (component_type* comp : components_)
+        {
+          component_internal_size += comp->getInternalSize();
+        }
 
-      // Allocation always rebuilds the system Jacobian and its COO-to-CSR map.
-      delete csr_jac_;
-      csr_jac_ = nullptr;
+        size_t node_internal_size = 0;
+        for (node_type* node : nodes_)
+        {
+          node_internal_size += node->getInternalSize();
+        }
 
-      delete[] map_to_csr_;
-      map_to_csr_ = nullptr;
+        n_intern_ = component_internal_size + node_internal_size;
+        n_extern_ = 0;
+        size_     = n_intern_ + n_extern_;
 
-      if (!allocated_)
-      {
-        allocateVectors(static_cast<IdxT>(size_), true);
-        // Component and node offsets can change when topology is modified.
-        abs_tol_.setToZero(memory::HOST);
-      }
+        // Allocation always rebuilds the system Jacobian and its COO-to-CSR map.
+        delete csr_jac_;
+        csr_jac_ = nullptr;
 
-      tag_.resize(size_);
+        delete[] map_to_csr_;
+        map_to_csr_ = nullptr;
 
-      { // Start node internal indexing after all component internals for proper KLU ordering
-        size_t node_internal_idx = component_internal_size;
-        for (node_type* node : nodes_)
+        if (!allocated_)
         {
-          node->allocate();
+          allocateVectors(static_cast<IdxT>(size_), true);
+          // Component and node offsets can change when topology is modified.
+          abs_tol_.setToZero(memory::HOST);
+        }
+
+        tag_.resize(size_);
 
-          for (size_t i = 0; i < node->getInternalSize(); i++)
+        { // Start node internal indexing after all component internals for proper KLU ordering
+          size_t node_internal_idx = component_internal_size;
+          for (node_type* node : nodes_)
           {
-            ExternalConnection<ScalarT, IdxT> node_connection{
-                .y_   = y_int_ + node_internal_idx,
-                .yp_  = yp_int_ + node_internal_idx,
-                .f_   = f_int_ + node_internal_idx,
-                .idx_ = static_cast<IdxT>(node_internal_idx)};
-
-            node->setExternalConnectionNodes(i, node_connection);
-            node_internal_idx++;
+            node->allocate();
+
+            for (size_t i = 0; i < node->getInternalSize(); i++)
+            {
+              ExternalConnection<ScalarT, IdxT> node_connection{
+                  .y_   = y_int_ + node_internal_idx,
+                  .yp_  = yp_int_ + node_internal_idx,
+                  .f_   = f_int_ + node_internal_idx,
+                  .idx_ = static_cast<IdxT>(node_internal_idx)};
+
+              node->setExternalConnectionNodes(i, node_connection);
+              node_internal_idx++;
+            }
           }
         }
-      }
 
-      {
-        // The offset for each component's internal variables in the system vector.
-        // They start at 0, and are stacked on top of each other.
-        size_t component_internal_idx = 0;
-        for (component_type* comp : components_)
         {
-          comp->allocate();
+          // The offset for each component's internal variables in the system vector.
+          // They start at 0, and are stacked on top of each other.
+          size_t component_internal_idx = 0;
+          for (component_type* comp : components_)
+          {
+            comp->allocate();
 
-          // Update component internal pointers to their correct offsets
-          comp->setInternalPointer(&y_int_[component_internal_idx]);
-          comp->setInternalDerivativePointer(&yp_int_[component_internal_idx]);
-          comp->setInternalResidualPointer(&f_int_[component_internal_idx]);
+            // Update component internal pointers to their correct offsets
+            comp->setInternalPointer(&y_int_[component_internal_idx]);
+            comp->setInternalDerivativePointer(&yp_int_[component_internal_idx]);
+            comp->setInternalResidualPointer(&f_int_[component_internal_idx]);
 
-          const auto& external_indices = comp->getExternIndices();
-          for (IdxT i = 0; i < comp->size(); i++)
-          {
-            if (!external_indices.contains(i))
+            const auto& external_indices = comp->getExternIndices();
+            for (IdxT i = 0; i < comp->size(); i++)
             {
-              comp->setInternalConnectionNodes(i, component_internal_idx);
-              component_internal_idx++;
+              if (!external_indices.contains(i))
+              {
+                comp->setInternalConnectionNodes(i, component_internal_idx);
+                component_internal_idx++;
+              }
             }
           }
         }
-      }
 
-      // Evaluate component Jacobians to get sparsity
-      for (component_type* component : components_)
-      {
-        component->evaluateJacobian();
-      }
-
-      // Count the number of non-zeros
-      IdxT nnz_dup = 0;
-      for (const component_type* component : components_)
-      {
-        const IdxT* r   = component->jacobianCooRows();
-        const IdxT* c   = component->jacobianCooCols();
-        IdxT        nnz = component->nnz();
+        // Evaluate component Jacobians to get sparsity
+        for (component_type* component : components_)
+        {
+          component->evaluateJacobian();
+        }
 
-        for (IdxT i = 0; i < nnz; ++i)
+        // Count the number of non-zeros
+        IdxT nnz_dup = 0;
+        for (const component_type* component : components_)
         {
-          if (component->getNodeConnection(r[i]) != neg1_ && component->getNodeConnection(c[i]) != neg1_)
+          const IdxT* r   = component->jacobianCooRows();
+          const IdxT* c   = component->jacobianCooCols();
+          IdxT        nnz = component->nnz();
+
+          for (IdxT i = 0; i < nnz; ++i)
           {
-            ++nnz_dup;
+            if (component->getNodeConnection(r[i]) != neg1_ && component->getNodeConnection(c[i]) != neg1_)
+            {
+              ++nnz_dup;
+            }
           }
         }
-      }
-
-      // Allocate COO triplet arrays (we own these until we hand off to CsrMatrix)
-      IdxT*  rows_dup = new IdxT[nnz_dup];
-      IdxT*  cols_dup = new IdxT[nnz_dup];
-      RealT* vals_dup = new RealT[nnz_dup];
 
-      IdxT counter = 0;
-      for (const component_type* component : components_)
-      {
-        const IdxT*  r   = component->jacobianCooRows();
-        const IdxT*  c   = component->jacobianCooCols();
-        const RealT* v   = component->jacobianCooValues();
-        IdxT         nnz = component->nnz();
+        // Allocate COO triplet arrays (we own these until we hand off to CsrMatrix)
+        IdxT*  rows_dup = new IdxT[nnz_dup];
+        IdxT*  cols_dup = new IdxT[nnz_dup];
+        RealT* vals_dup = new RealT[nnz_dup];
 
-        for (IdxT i = 0; i < nnz; ++i)
+        IdxT counter = 0;
+        for (const component_type* component : components_)
         {
-          if (component->getNodeConnection(r[i]) != neg1_ && component->getNodeConnection(c[i]) != neg1_)
+          const IdxT*  r   = component->jacobianCooRows();
+          const IdxT*  c   = component->jacobianCooCols();
+          const RealT* v   = component->jacobianCooValues();
+          IdxT         nnz = component->nnz();
+
+          for (IdxT i = 0; i < nnz; ++i)
           {
-            rows_dup[counter] = component->getNodeConnection(r[i]);
-            cols_dup[counter] = component->getNodeConnection(c[i]);
-            vals_dup[counter] = v[i];
-            counter++;
+            if (component->getNodeConnection(r[i]) != neg1_ && component->getNodeConnection(c[i]) != neg1_)
+            {
+              rows_dup[counter] = component->getNodeConnection(r[i]);
+              cols_dup[counter] = component->getNodeConnection(c[i]);
+              vals_dup[counter] = v[i];
+              counter++;
+            }
           }
         }
-      }
 
-      // Build the system COO Jacobian
-      LinearAlgebra::CooMatrix<RealT, IdxT> jac(size_, size_, nnz_dup, &rows_dup, &cols_dup, &vals_dup);
+        // Build the system COO Jacobian
+        LinearAlgebra::CooMatrix<RealT, IdxT> jac(size_, size_, nnz_dup, &rows_dup, &cols_dup, &vals_dup);
+
+        // Populate CSR data with sort and deduplicate
+        IdxT* row_ptrs = jac.getCsrRowData();
 
-      // Populate CSR data with sort and deduplicate
-      IdxT* row_ptrs = jac.getCsrRowData();
+        // Deduplicated nnz
+        nnz_ = jac.getNnz();
 
-      // Deduplicated nnz
-      nnz_ = jac.getNnz();
+        // Allocate cols/vals with deduplicated nnz
+        IdxT*  cols = new IdxT[nnz_];
+        RealT* vals = new RealT[nnz_];
 
-      // Allocate cols/vals with deduplicated nnz
-      IdxT*  cols = new IdxT[nnz_];
-      RealT* vals = new RealT[nnz_];
+        std::copy(jac.getColData(), jac.getColData() + nnz_, cols);
+        std::copy(jac.getValues(), jac.getValues() + nnz_, vals);
 
-      std::copy(jac.getColData(), jac.getColData() + nnz_, cols);
-      std::copy(jac.getValues(), jac.getValues() + nnz_, vals);
+        // Create the CSR Jacobian
+        csr_jac_ = new CsrMatrixT(size_, size_, nnz_, &row_ptrs, &cols, &vals);
 
-      // Create the CSR Jacobian
-      csr_jac_ = new CsrMatrixT(size_, size_, nnz_, &row_ptrs, &cols, &vals);
+        const IdxT* map_to_sorted = jac.getMapToSorted();
+        const IdxT* map_to_dedup  = jac.getMapToDeduplicated();
 
-      const IdxT* map_to_sorted = jac.getMapToSorted();
-      const IdxT* map_to_dedup  = jac.getMapToDeduplicated();
+        // Build a mappping from original COO index to CSR index
+        map_to_csr_ = new IdxT[nnz_dup];
+        for (IdxT i = 0; i < nnz_dup; ++i)
+        {
+          map_to_csr_[map_to_sorted[i]] = map_to_dedup[i];
+        }
+
+        allocated_ = true;
+        return 0;
+      }
 
-      // Build a mappping from original COO index to CSR index
-      map_to_csr_ = new IdxT[nnz_dup];
-      for (IdxT i = 0; i < nnz_dup; ++i)
+      /**
+       * @brief Set intial y and y' of each component
+       *
+       * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
+       */
+      int initialize() final
       {
-        map_to_csr_[map_to_sorted[i]] = map_to_dedup[i];
+        // Initialize components
+        for (const auto& component : components_)
+        {
+          component->initialize();
+        }
+
+        return CircuitComponent<ScalarT, IdxT>::initialize();
       }
 
-      allocated_ = true;
-      return 0;
-    }
+      /**
+       * @brief Tags all system variables as differentiable, based on what the
+       * components that own those variables tag them as.
+       *
+       * Starts by asking all components to tag their differentiables. This implementation
+       * assumes all node variables are algebraic, and will not ask nodes to tag their differentiables.
+       * Sets all variables to algebraic (`false`) to start, then loops over all component internal variables.
+       * Re-creates the same internal variable to system variables mapping as in \ref allocate() - all
+       * internal variables from the same component are stored contiguously in a block, and blocks are
+       * stored contiguously in the same order as \ref components_, with node variables at the end.
+       * Each internal variable's tag in the system is set to its tag in the component.
+       */
+      int tagDifferentiable() final
+      {
+        // Ask all component to tag their differentiables
+        for (size_t i = 0; i < components_.size(); i++)
+        {
+          component_type* component = components_[i];
 
-    /**
-     * @brief Set intial y and y' of each component
-     *
-     * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
-     */
-    int initialize() final
-    {
-      // Initialize components
-      for (const auto& component : components_)
+          // Bubble up errors if necessary
+          if (int err = component->tagDifferentiable())
+          {
+            return err;
+          }
+        }
+
+        // Fill tags with a default value (false) for node variables. Assumed to be algebraic here.
+        std::fill(tag_.begin(), tag_.end(), false);
+
+        // Copy tags for internal variables from their components - going in the order as described above
+        size_t idx = 0;
+        for (component_type* comp : components_)
+        {
+          const auto& external_indices = comp->getExternIndices();
+
+          // Loop over all component variables - including externals
+          for (IdxT i = 0; i < comp->size(); i++)
+          {
+            // Discard externals
+            if (!external_indices.contains(i))
+            {
+              tag_[idx] = comp->tag()[i];
+
+              // Ensures internal variables are contiguous, and in the same order as the component
+              idx++;
+            }
+          }
+        }
+
+        return 0;
+      }
+
+      /**
+       * @brief Compute the absolute tolerance for each variable in the model
+       *
+       * @param rel_tol The relative tolerance which can be used to pick the
+       *        absolute tolerance.
+       * @tparam ScalarT Scalar data type
+       * @tparam IdxT Index data type
+       * @return int 0 if successful, non-zero otherwise.
+       *
+       * This represents a "noise" level close to zero for which pure relative
+       * error cannot be used.
+       */
+      int setAbsoluteTolerance(RealT rel_tol) final
       {
-        component->initialize();
+        abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+        return 0;
       }
 
-      return CircuitComponent<ScalarT, IdxT>::initialize();
-    }
-
-    /**
-     * @brief Tags all system variables as differentiable, based on what the
-     * components that own those variables tag them as.
-     *
-     * Starts by asking all components to tag their differentiables. This implementation
-     * assumes all node variables are algebraic, and will not ask nodes to tag their differentiables.
-     * Sets all variables to algebraic (`false`) to start, then loops over all component internal variables.
-     * Re-creates the same internal variable to system variables mapping as in \ref allocate() - all
-     * internal variables from the same component are stored contiguously in a block, and blocks are
-     * stored contiguously in the same order as \ref components_, with node variables at the end.
-     * Each internal variable's tag in the system is set to its tag in the component.
-     */
-    int tagDifferentiable() final
-    {
-      // Ask all component to tag their differentiables
-      for (size_t i = 0; i < components_.size(); i++)
+      /**
+       * @brief Evaluate Residuals at each component then collect them
+       *
+       * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
+       */
+      int evaluateInternalResidual() final
       {
-        component_type* component = components_[i];
+        for (IdxT i = 0; i < size_; i++)
+        {
+          f_int_[i] = 0.0;
+        }
 
-        // Bubble up errors if necessary
-        if (int err = component->tagDifferentiable())
+        // Update system residual vector
+
+        // Evaluate component internal residuals - this is embarassingly parallel
+        for (component_type* component : components_)
+        {
+          if (int err_code = component->evaluateInternalResidual())
+            return err_code;
+        }
+
+        for (component_type* component : components_)
         {
-          return err;
+          if (int err_code = component->evaluateExternalResidual())
+            return err_code;
         }
+
+        return 0;
       }
 
-      // Fill tags with a default value (false) for node variables. Assumed to be algebraic here.
-      std::fill(tag_.begin(), tag_.end(), false);
+      /**
+       * @todo implement this for nested systems
+       */
+      int evaluateExternalResidual() final
+      {
+        return 0;
+      }
 
-      // Copy tags for internal variables from their components - going in the order as described above
-      size_t idx = 0;
-      for (component_type* comp : components_)
+      /**
+       * @brief Creates the system Jacobian representing \f$\alpha dF/dy' + dF/dy\f$
+       *
+       * Updates the CSR Jacobian values using the per-component mappings
+       * computed during allocate().
+       *
+       * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
+       */
+      int evaluateJacobian() final
       {
-        const auto& external_indices = comp->getExternIndices();
+        // Zero out values
+        RealT* vals = csr_jac_->getValues();
+        for (IdxT i = 0; i < csr_jac_->getNnz(); ++i)
+        {
+          vals[i] = 0.0;
+        }
 
-        // Loop over all component variables - including externals
-        for (IdxT i = 0; i < comp->size(); i++)
+        // Update CSR values from component Jacobians
+        IdxT counter = 0;
+        for (const auto& component : components_)
         {
-          // Discard externals
-          if (!external_indices.contains(i))
-          {
-            tag_[idx] = comp->tag()[i];
+          component->evaluateJacobian();
 
-            // Ensures internal variables are contiguous, and in the same order as the component
-            idx++;
+          const IdxT*  r   = component->jacobianCooRows();
+          const IdxT*  c   = component->jacobianCooCols();
+          const RealT* v   = component->jacobianCooValues();
+          IdxT         nnz = component->nnz();
+
+          for (IdxT i = 0; i < nnz; ++i)
+          {
+            if (component->getNodeConnection(r[i]) != neg1_ && component->getNodeConnection(c[i]) != neg1_)
+            {
+              vals[map_to_csr_[counter]] += v[i];
+              ++counter;
+            }
           }
         }
+
+        jac_call_count_++;
+        return 0;
       }
 
-      return 0;
-    }
-
-    /**
-     * @brief Compute the absolute tolerance for each variable in the model
-     *
-     * @param rel_tol The relative tolerance which can be used to pick the
-     *        absolute tolerance.
-     * @tparam ScalarT Scalar data type
-     * @tparam IdxT Index data type
-     * @return int 0 if successful, non-zero otherwise.
-     *
-     * This represents a "noise" level close to zero for which pure relative
-     * error cannot be used.
-     */
-    int setAbsoluteTolerance(RealT rel_tol) final
-    {
-      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-      return 0;
-    }
-
-    /**
-     * @brief Evaluate Residuals at each component then collect them
-     *
-     * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
-     */
-    int evaluateInternalResidual() final
-    {
-      for (IdxT i = 0; i < size_; i++)
+      /**
+       * @brief Evaluate integrands for the system quadratures.
+       */
+      int evaluateIntegrand() final
       {
-        f_int_[i] = 0.0;
+        return 0;
       }
 
-      // Update system residual vector
-
-      // Evaluate component internal residuals - this is embarassingly parallel
-      for (component_type* component : components_)
+      /**
+       * @brief Initialize system adjoint.
+       *
+       * Updates variables and optimization parameters, then initializes
+       * adjoints locally and copies them to the system adjoint vector.
+       */
+      int initializeAdjoint() final
       {
-        if (int err_code = component->evaluateInternalResidual())
-          return err_code;
+        return 0;
       }
 
-      for (component_type* component : components_)
+      /**
+       * @brief Compute adjoint residual for the system model.
+       *
+       *
+       */
+      int evaluateAdjointResidual() final
       {
-        if (int err_code = component->evaluateExternalResidual())
-          return err_code;
+        return 0;
       }
 
-      return 0;
-    }
-
-    /**
-     * @todo implement this for nested systems
-     */
-    int evaluateExternalResidual() final
-    {
-      return 0;
-    }
-
-    /**
-     * @brief Creates the system Jacobian representing \f$\alpha dF/dy' + dF/dy\f$
-     *
-     * Updates the CSR Jacobian values using the per-component mappings
-     * computed during allocate().
-     *
-     * @return int 0 if successful, positive if there's a recoverable error, negative if unrecoverable
-     */
-    int evaluateJacobian() final
-    {
-      // Zero out values
-      RealT* vals = csr_jac_->getValues();
-      for (IdxT i = 0; i < csr_jac_->getNnz(); ++i)
+      /**
+       * @brief Evaluate adjoint integrand for the system model.
+       *
+       *
+       */
+      int evaluateAdjointIntegrand() final
       {
-        vals[i] = 0.0;
+        return 0;
       }
 
-      // Update CSR values from component Jacobians
-      IdxT counter = 0;
-      for (const auto& component : components_)
+      /**
+       * @brief Distribute time and time scaling for each component
+       *
+       * @param t
+       * @param a
+       */
+      void updateTime(RealT t, RealT a) final
       {
-        component->evaluateJacobian();
-
-        const IdxT*  r   = component->jacobianCooRows();
-        const IdxT*  c   = component->jacobianCooCols();
-        const RealT* v   = component->jacobianCooValues();
-        IdxT         nnz = component->nnz();
-
-        for (IdxT i = 0; i < nnz; ++i)
+        for (const auto& component : components_)
         {
-          if (component->getNodeConnection(r[i]) != neg1_ && component->getNodeConnection(c[i]) != neg1_)
-          {
-            vals[map_to_csr_[counter]] += v[i];
-            ++counter;
-          }
+          component->updateTime(t, a);
         }
+        time_  = t;
+        alpha_ = a;
       }
 
-      jac_call_count_++;
-      return 0;
-    }
-
-    /**
-     * @brief Evaluate integrands for the system quadratures.
-     */
-    int evaluateIntegrand() final
-    {
-      return 0;
-    }
-
-    /**
-     * @brief Initialize system adjoint.
-     *
-     * Updates variables and optimization parameters, then initializes
-     * adjoints locally and copies them to the system adjoint vector.
-     */
-    int initializeAdjoint() final
-    {
-      return 0;
-    }
-
-    /**
-     * @brief Compute adjoint residual for the system model.
-     *
-     *
-     */
-    int evaluateAdjointResidual() final
-    {
-      return 0;
-    }
-
-    /**
-     * @brief Evaluate adjoint integrand for the system model.
-     *
-     *
-     */
-    int evaluateAdjointIntegrand() final
-    {
-      return 0;
-    }
-
-    /**
-     * @brief Distribute time and time scaling for each component
-     *
-     * @param t
-     * @param a
-     */
-    void updateTime(RealT t, RealT a) final
-    {
-      for (const auto& component : components_)
+      CsrMatrixT* getCsrJacobian() const override
       {
-        component->updateTime(t, a);
+        return csr_jac_;
       }
-      time_  = t;
-      alpha_ = a;
-    }
-
-    CsrMatrixT* getCsrJacobian() const override
-    {
-      return csr_jac_;
-    }
-
-    void addComponent(component_type* component)
-    {
-      components_.push_back(component);
-      allocated_ = false;
-    }
 
-    void addNode(node_type* node)
-    {
-      nodes_.push_back(node);
-      allocated_ = false;
-    }
+      void addComponent(component_type* component)
+      {
+        components_.push_back(component);
+        allocated_ = false;
+      }
 
-  private:
-    static constexpr IdxT neg1_ = INVALID_INDEX<IdxT>;
+      void addNode(node_type* node)
+      {
+        nodes_.push_back(node);
+        allocated_ = false;
+      }
 
-    std::vector<component_type*> components_;
-    std::vector<node_type*>      nodes_;
+    private:
+      static constexpr IdxT neg1_ = INVALID_INDEX<IdxT>;
 
-    IdxT*       map_to_csr_{nullptr};
-    CsrMatrixT* csr_jac_{nullptr};
+      std::vector<component_type*> components_;
+      std::vector<node_type*>      nodes_;
 
-    int  jac_call_count_{0};
-    bool use_jac_;
+      IdxT*       map_to_csr_{nullptr};
+      CsrMatrixT* csr_jac_{nullptr};
 
-  }; // class PowerElectronicsModel
+      int  jac_call_count_{0};
+      bool use_jac_;
 
+    }; // class PowerElectronicsModel
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp
index f3be694d4..f5ea05cf7 100644
--- a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp
+++ b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp
@@ -7,214 +7,215 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a TransmissionLine model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   *
-   * This is the Medium distance form with the use of the admittance matrix.
-   * Since the line is of medium length then there is no real part for shunt admittance
-   * @todo needs to used in a model
-   * @todo test for correctness
-   */
-
-  template <class ScalarT, typename IdxT>
-  TransmissionLine<ScalarT, IdxT>::TransmissionLine(IdxT id, RealT R, RealT X, RealT B)
-    : R_(R),
-      X_(X),
-      B_(B)
-  {
-    // internals [Iret1, Iimt1, Iret2, Iimt2]
-    // externals [Vre11, Vim11, Vre12, Vim12, Vre21, Vim21, Vre22, Vim22]
-    size_           = 12;
-    n_intern_       = 4;
-    n_extern_       = 8;
-    extern_indices_ = {0, 1, 2, 3, 4, 5, 6, 7};
-    idc_            = id;
-    nnz_            = 44;
-
-    RealT magImpendence = 1.0 / (R_ * R_ + X_ * X_);
-    YReMat_             = magImpendence * R_;
-    YImMatOff_          = magImpendence * X_;
-    YImMatDi_           = B_ / (2.0) - YImMatOff_;
-  }
-
-  template <class ScalarT, typename IdxT>
-  TransmissionLine<ScalarT, IdxT>::~TransmissionLine()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are algebraics
-    std::fill(tag_.begin(), tag_.end(), false);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Evaluate residual of transmission line
-   *
-   * The complex admittance matrix is:
-   * [[ Y/2 + 1/Z, -1/Z];
-   *  [ -1/Z, Y/2 + 1/Z]] =
-   * [[R/|Z|, -R/|Z|];
-   *  [-R/|Z|, R/|Z|]] +
-   * i [[B/2 - X/|Z|, X/|Z|];
-   *    [X/|Z|, B/2 - X/|Z|]]
-   * = Dre + i Dim
-   *
-   * Then
-   *  Ire = Dre Vre - Dim Vim
-   *  Iim = Dre Vim + Dim Vre
-   *
-   * To express this for Modified Nodal Analysis the Voltages of the admittance matrix are put into voltage drops
-   */
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    // Voltage drop accross terminals
-    ScalarT V1re = *y_ext_[0] - *y_ext_[4];
-    ScalarT V1im = *y_ext_[1] - *y_ext_[5];
-    ScalarT V2re = *y_ext_[2] - *y_ext_[6];
-    ScalarT V2im = *y_ext_[3] - *y_ext_[7];
-
-    // Internal variables
-    // row 1
-    f_int_[0] = YReMat_ * (V1re - V2re) - (YImMatDi_ * V1im + YImMatOff_ * V2im) - y_int_[0];
-    f_int_[1] = YReMat_ * (V1im - V2im) + (YImMatDi_ * V1re + YImMatOff_ * V2re) - y_int_[1];
-
-    // row2
-    f_int_[2] = YReMat_ * (V2re - V1re) - (YImMatOff_ * V1im + YImMatDi_ * V2im) - y_int_[2];
-    f_int_[3] = YReMat_ * (V2im - V1im) + (YImMatOff_ * V1re + YImMatDi_ * V2re) - y_int_[3];
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // input
-    *f_ext_[0] += y_int_[0];
-    *f_ext_[1] += y_int_[1];
-
-    *f_ext_[2] += y_int_[2];
-    *f_ext_[3] += y_int_[3];
-    // ouput
-    *f_ext_[4] += -y_int_[0];
-    *f_ext_[5] += -y_int_[1];
-
-    *f_ext_[6] += -y_int_[2];
-    *f_ext_[7] += -y_int_[3];
-
-    return 0;
-  }
-
-  /**
-   * @brief Generate Jacobian for Transmission Line
-   *
-   * @tparam ScalarT
-   * @tparam IdxT
-   * @return int
-   */
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
-
-    // Create dF/dy
-    std::vector<IdxT>  rtemp{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-    std::vector<IdxT>  ctemp{8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11};
-    std::vector<RealT> vals{1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0};
-    this->setJacValues(rtemp, ctemp, vals);
-
-    std::vector<IdxT> ccord{0, 1, 2, 3, 4, 5, 6, 7};
-
-    std::vector<IdxT> rcord(ccord.size(), 8);
-    vals = {YReMat_, -YImMatDi_, -YReMat_, -YImMatOff_, -YReMat_, YImMatDi_, YReMat_, YImMatOff_};
-    this->setJacValues(rtemp, ctemp, vals);
-
-    std::fill(rcord.begin(), rcord.end(), 9);
-    vals = {YImMatDi_, YReMat_, YImMatOff_, -YReMat_, -YImMatDi_, -YReMat_, -YImMatOff_, YReMat_};
-    this->setJacValues(rtemp, ctemp, vals);
-
-    std::fill(rcord.begin(), rcord.end(), 10);
-    vals = {-YReMat_, -YImMatDi_, YReMat_, -YImMatOff_, YReMat_, YImMatDi_, -YReMat_, YImMatOff_};
-    this->setJacValues(rtemp, ctemp, vals);
-
-    std::fill(rcord.begin(), rcord.end(), 11);
-    vals = {YImMatDi_, -YReMat_, YImMatOff_, YReMat_, -YImMatDi_, YReMat_, -YImMatOff_, -YReMat_};
-    this->setJacValues(rtemp, ctemp, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::initializeAdjoint()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int TransmissionLine<ScalarT, IdxT>::evaluateAdjointIntegrand()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* TransmissionLine<ScalarT, IdxT>::clone() const
-  {
-    return new TransmissionLine<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class TransmissionLine<double, long int>;
-  template class TransmissionLine<double, size_t>;
-  template class TransmissionLine<DependencyTracking::Variable, long int>;
-  template class TransmissionLine<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a TransmissionLine model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     *
+     * This is the Medium distance form with the use of the admittance matrix.
+     * Since the line is of medium length then there is no real part for shunt admittance
+     * @todo needs to used in a model
+     * @todo test for correctness
+     */
+    template <class ScalarT, typename IdxT>
+    TransmissionLine<ScalarT, IdxT>::TransmissionLine(IdxT id, RealT R, RealT X, RealT B)
+      : R_(R),
+        X_(X),
+        B_(B)
+    {
+      // internals [Iret1, Iimt1, Iret2, Iimt2]
+      // externals [Vre11, Vim11, Vre12, Vim12, Vre21, Vim21, Vre22, Vim22]
+      size_           = 12;
+      n_intern_       = 4;
+      n_extern_       = 8;
+      extern_indices_ = {0, 1, 2, 3, 4, 5, 6, 7};
+      idc_            = id;
+      nnz_            = 44;
+
+      RealT magImpendence = 1.0 / (R_ * R_ + X_ * X_);
+      YReMat_             = magImpendence * R_;
+      YImMatOff_          = magImpendence * X_;
+      YImMatDi_           = B_ / (2.0) - YImMatOff_;
+    }
+
+    template <class ScalarT, typename IdxT>
+    TransmissionLine<ScalarT, IdxT>::~TransmissionLine()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are algebraics
+      std::fill(tag_.begin(), tag_.end(), false);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Evaluate residual of transmission line
+     *
+     * The complex admittance matrix is:
+     * [[ Y/2 + 1/Z, -1/Z];
+     *  [ -1/Z, Y/2 + 1/Z]] =
+     * [[R/|Z|, -R/|Z|];
+     *  [-R/|Z|, R/|Z|]] +
+     * i [[B/2 - X/|Z|, X/|Z|];
+     *    [X/|Z|, B/2 - X/|Z|]]
+     * = Dre + i Dim
+     *
+     * Then
+     *  Ire = Dre Vre - Dim Vim
+     *  Iim = Dre Vim + Dim Vre
+     *
+     * To express this for Modified Nodal Analysis the Voltages of the admittance matrix are put into voltage drops
+     */
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      // Voltage drop accross terminals
+      ScalarT V1re = *y_ext_[0] - *y_ext_[4];
+      ScalarT V1im = *y_ext_[1] - *y_ext_[5];
+      ScalarT V2re = *y_ext_[2] - *y_ext_[6];
+      ScalarT V2im = *y_ext_[3] - *y_ext_[7];
+
+      // Internal variables
+      // row 1
+      f_int_[0] = YReMat_ * (V1re - V2re) - (YImMatDi_ * V1im + YImMatOff_ * V2im) - y_int_[0];
+      f_int_[1] = YReMat_ * (V1im - V2im) + (YImMatDi_ * V1re + YImMatOff_ * V2re) - y_int_[1];
+
+      // row2
+      f_int_[2] = YReMat_ * (V2re - V1re) - (YImMatOff_ * V1im + YImMatDi_ * V2im) - y_int_[2];
+      f_int_[3] = YReMat_ * (V2im - V1im) + (YImMatOff_ * V1re + YImMatDi_ * V2re) - y_int_[3];
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // input
+      *f_ext_[0] += y_int_[0];
+      *f_ext_[1] += y_int_[1];
+
+      *f_ext_[2] += y_int_[2];
+      *f_ext_[3] += y_int_[3];
+      // ouput
+      *f_ext_[4] += -y_int_[0];
+      *f_ext_[5] += -y_int_[1];
+
+      *f_ext_[6] += -y_int_[2];
+      *f_ext_[7] += -y_int_[3];
+
+      return 0;
+    }
+
+    /**
+     * @brief Generate Jacobian for Transmission Line
+     *
+     * @tparam ScalarT
+     * @tparam IdxT
+     * @return int
+     */
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      // Create dF/dy
+      std::vector<IdxT>  rtemp{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+      std::vector<IdxT>  ctemp{8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11};
+      std::vector<RealT> vals{1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0};
+      this->setJacValues(rtemp, ctemp, vals);
+
+      std::vector<IdxT> ccord{0, 1, 2, 3, 4, 5, 6, 7};
+
+      std::vector<IdxT> rcord(ccord.size(), 8);
+      vals = {YReMat_, -YImMatDi_, -YReMat_, -YImMatOff_, -YReMat_, YImMatDi_, YReMat_, YImMatOff_};
+      this->setJacValues(rtemp, ctemp, vals);
+
+      std::fill(rcord.begin(), rcord.end(), 9);
+      vals = {YImMatDi_, YReMat_, YImMatOff_, -YReMat_, -YImMatDi_, -YReMat_, -YImMatOff_, YReMat_};
+      this->setJacValues(rtemp, ctemp, vals);
+
+      std::fill(rcord.begin(), rcord.end(), 10);
+      vals = {-YReMat_, -YImMatDi_, YReMat_, -YImMatOff_, YReMat_, YImMatDi_, -YReMat_, YImMatOff_};
+      this->setJacValues(rtemp, ctemp, vals);
+
+      std::fill(rcord.begin(), rcord.end(), 11);
+      vals = {YImMatDi_, -YReMat_, YImMatOff_, YReMat_, -YImMatDi_, YReMat_, -YImMatOff_, -YReMat_};
+      this->setJacValues(rtemp, ctemp, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int TransmissionLine<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* TransmissionLine<ScalarT, IdxT>::clone() const
+    {
+      return new TransmissionLine<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class TransmissionLine<double, long int>;
+    template class TransmissionLine<double, size_t>;
+    template class TransmissionLine<DependencyTracking::Variable, long int>;
+    template class TransmissionLine<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp
index 7a0bfb230..3166353d3 100644
--- a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp
+++ b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -12,68 +11,71 @@ namespace GridKit
 
 namespace GridKit
 {
-  /*!
-   * @brief Declaration of a TransmissionLine class.
-   *
-   * Model from Adam Birchfield paper (medium distances < 2km).
-   * See also textbooks "Power System Analysis" by Grainger and "Power System Dynamics and Stability" by Sauer & Pai
-   *
-   * @note Not used in the Microgrid model.
-   */
-  template <class ScalarT, typename IdxT>
-  class TransmissionLine : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+    /*!
+     * @brief Declaration of a TransmissionLine class.
+     *
+     * Model from Adam Birchfield paper (medium distances < 2km).
+     * See also textbooks "Power System Analysis" by Grainger and "Power System Dynamics and Stability" by Sauer & Pai
+     *
+     * @note Not used in the Microgrid model.
+     */
+    template <class ScalarT, typename IdxT>
+    class TransmissionLine : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    TransmissionLine(IdxT id, RealT R, RealT X, RealT B);
-    virtual ~TransmissionLine();
+    public:
+      TransmissionLine(IdxT id, RealT R, RealT X, RealT B);
+      virtual ~TransmissionLine();
 
-    int initialize();
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian();
-    int evaluateIntegrand();
+      int initialize();
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian();
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT R_;
-    RealT X_;
-    RealT B_;
-    RealT YReMat_;
-    RealT YImMatDi_;
-    RealT YImMatOff_;
-  };
+    private:
+      RealT R_;
+      RealT X_;
+      RealT B_;
+      RealT YReMat_;
+      RealT YImMatDi_;
+      RealT YImMatOff_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp
index 900d2fc64..66b207094 100644
--- a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp
+++ b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp
@@ -1,5 +1,4 @@
 
-
 #include "VoltageSource.hpp"
 
 #include <cmath>
@@ -8,150 +7,151 @@
 
 namespace GridKit
 {
-
-  /*!
-   * @brief Constructor for a constant VoltageSource model
-   *
-   * Calls default ModelEvaluatorImpl constructor.
-   */
-
-  template <class ScalarT, typename IdxT>
-  VoltageSource<ScalarT, IdxT>::VoltageSource(IdxT id, RealT V, NodeT* node1, NodeT* node2)
-    : V_(V), node1_(node1), node2_(node2)
-  {
-    assert(node1_->size() == 1);
-    assert(node2_->size() == 1);
-    size_           = 3;
-    n_intern_       = 1;
-    n_extern_       = 2;
-    extern_indices_ = {0, 1};
-    idc_            = id;
-    nnz_            = 4;
-  }
-
-  template <class ScalarT, typename IdxT>
-  VoltageSource<ScalarT, IdxT>::~VoltageSource()
-  {
-  }
-
-  /**
-   * Initialization of the grid model
-   */
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::initialize()
-  {
-    return 0;
-  }
-
-  /*
-   * \brief Identify differential variables
-   */
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::tagDifferentiable()
-  {
-    // All variables are algebraics
-    std::fill(tag_.begin(), tag_.end(), false);
-    return 0;
-  }
-
-  /**
-   * @brief Compute the absolute tolerance for each variable in the model
-   *
-   * @param rel_tol The relative tolerance which can be used to pick the
-   *        absolute tolerance.
-   * @tparam ScalarT Scalar data type
-   * @tparam IdxT Index data type
-   * @return int 0 if successful, non-zero otherwise.
-   *
-   * This represents a "noise" level close to zero for which pure relative
-   * error cannot be used.
-   */
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
-  {
-    abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
-    return 0;
-  }
-
-  /**
-   * @brief Evaluate resisdual of component
-   */
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::evaluateInternalResidual()
-  {
-    f_int_[0] = *y_ext_[1] - *y_ext_[0] - V_;
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::evaluateExternalResidual()
-  {
-    // input
-    *f_ext_[0] += -y_int_[0];
-    // ouput
-    *f_ext_[1] += y_int_[0];
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::evaluateJacobian()
-  {
-    this->zeroJacMatrix();
-
-    // Create dF/dy
-    std::vector<IdxT>  rcord{0, 1, 2, 2};
-    std::vector<IdxT>  ccord{2, 2, 0, 1};
-    std::vector<RealT> vals{-1.0, 1.0, -1.0, 1.0};
-    this->setJacValues(rcord, ccord, vals);
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::allocate()
-  {
-    CircuitComponent<ScalarT, IdxT>::allocate();
-
-    this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
-    this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
-
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::evaluateIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::initializeAdjoint()
+  namespace PowerElectronics
   {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::evaluateAdjointResidual()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  int VoltageSource<ScalarT, IdxT>::evaluateAdjointIntegrand()
-  {
-    return 0;
-  }
-
-  template <class ScalarT, typename IdxT>
-  CircuitComponent<ScalarT, IdxT>* VoltageSource<ScalarT, IdxT>::clone() const
-  {
-    return new VoltageSource<ScalarT, IdxT>(*this);
-  }
-
-  // Available template instantiations
-  template class VoltageSource<double, long int>;
-  template class VoltageSource<double, size_t>;
-  template class VoltageSource<DependencyTracking::Variable, long int>;
-  template class VoltageSource<DependencyTracking::Variable, size_t>;
-
+    /*!
+     * @brief Constructor for a constant VoltageSource model
+     *
+     * Calls default ModelEvaluatorImpl constructor.
+     */
+    template <class ScalarT, typename IdxT>
+    VoltageSource<ScalarT, IdxT>::VoltageSource(IdxT id, RealT V, NodeT* node1, NodeT* node2)
+      : V_(V), node1_(node1), node2_(node2)
+    {
+      assert(node1_->size() == 1);
+      assert(node2_->size() == 1);
+      size_           = 3;
+      n_intern_       = 1;
+      n_extern_       = 2;
+      extern_indices_ = {0, 1};
+      idc_            = id;
+      nnz_            = 4;
+    }
+
+    template <class ScalarT, typename IdxT>
+    VoltageSource<ScalarT, IdxT>::~VoltageSource()
+    {
+    }
+
+    /**
+     * Initialization of the grid model
+     */
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::initialize()
+    {
+      return 0;
+    }
+
+    /*
+     * \brief Identify differential variables
+     */
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::tagDifferentiable()
+    {
+      // All variables are algebraics
+      std::fill(tag_.begin(), tag_.end(), false);
+      return 0;
+    }
+
+    /**
+     * @brief Compute the absolute tolerance for each variable in the model
+     *
+     * @param rel_tol The relative tolerance which can be used to pick the
+     *        absolute tolerance.
+     * @tparam ScalarT Scalar data type
+     * @tparam IdxT Index data type
+     * @return int 0 if successful, non-zero otherwise.
+     *
+     * This represents a "noise" level close to zero for which pure relative
+     * error cannot be used.
+     */
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::setAbsoluteTolerance(RealT rel_tol)
+    {
+      abs_tol_.setToConst(static_cast<ScalarT>(rel_tol));
+      return 0;
+    }
+
+    /**
+     * @brief Evaluate resisdual of component
+     */
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::evaluateInternalResidual()
+    {
+      f_int_[0] = *y_ext_[1] - *y_ext_[0] - V_;
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::evaluateExternalResidual()
+    {
+      // input
+      *f_ext_[0] += -y_int_[0];
+      // ouput
+      *f_ext_[1] += y_int_[0];
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::evaluateJacobian()
+    {
+      this->zeroJacMatrix();
+
+      // Create dF/dy
+      std::vector<IdxT>  rcord{0, 1, 2, 2};
+      std::vector<IdxT>  ccord{2, 2, 0, 1};
+      std::vector<RealT> vals{-1.0, 1.0, -1.0, 1.0};
+      this->setJacValues(rcord, ccord, vals);
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::allocate()
+    {
+      CircuitComponent<ScalarT, IdxT>::allocate();
+
+      this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
+      this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
+
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::evaluateIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::initializeAdjoint()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::evaluateAdjointResidual()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    int VoltageSource<ScalarT, IdxT>::evaluateAdjointIntegrand()
+    {
+      return 0;
+    }
+
+    template <class ScalarT, typename IdxT>
+    CircuitComponent<ScalarT, IdxT>* VoltageSource<ScalarT, IdxT>::clone() const
+    {
+      return new VoltageSource<ScalarT, IdxT>(*this);
+    }
+
+    // Available template instantiations
+    template class VoltageSource<double, long int>;
+    template class VoltageSource<double, size_t>;
+    template class VoltageSource<DependencyTracking::Variable, long int>;
+    template class VoltageSource<DependencyTracking::Variable, size_t>;
+
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp
index 0cc94f66c..d7ddda194 100644
--- a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp
+++ b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp
@@ -1,5 +1,4 @@
 
-
 #pragma once
 
 #include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
@@ -7,69 +6,66 @@
 
 namespace GridKit
 {
-  template <class ScalarT, typename IdxT>
-  class BaseBus;
-}
-
-namespace GridKit
-{
-  /*!
-   * @brief Declaration of a VoltageSource class.
-   *
-   */
-  template <class ScalarT, typename IdxT>
-  class VoltageSource : public CircuitComponent<ScalarT, IdxT>
+  namespace PowerElectronics
   {
-    using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
-    using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
+    /*!
+     * @brief Declaration of a VoltageSource class.
+     *
+     */
+    template <class ScalarT, typename IdxT>
+    class VoltageSource : public CircuitComponent<ScalarT, IdxT>
+    {
+      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-    using CircuitComponent<ScalarT, IdxT>::size_;
-    using CircuitComponent<ScalarT, IdxT>::nnz_;
-    using CircuitComponent<ScalarT, IdxT>::time_;
-    using CircuitComponent<ScalarT, IdxT>::alpha_;
-    using CircuitComponent<ScalarT, IdxT>::y_ext_;
-    using CircuitComponent<ScalarT, IdxT>::y_int_;
-    using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-    using CircuitComponent<ScalarT, IdxT>::yp_int_;
-    using CircuitComponent<ScalarT, IdxT>::tag_;
-    using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-    using CircuitComponent<ScalarT, IdxT>::f_ext_;
-    using CircuitComponent<ScalarT, IdxT>::f_int_;
-    using CircuitComponent<ScalarT, IdxT>::g_;
-    using CircuitComponent<ScalarT, IdxT>::yB_;
-    using CircuitComponent<ScalarT, IdxT>::ypB_;
-    using CircuitComponent<ScalarT, IdxT>::fB_;
-    using CircuitComponent<ScalarT, IdxT>::gB_;
-    using CircuitComponent<ScalarT, IdxT>::param_;
-    using CircuitComponent<ScalarT, IdxT>::idc_;
+      using CircuitComponent<ScalarT, IdxT>::size_;
+      using CircuitComponent<ScalarT, IdxT>::nnz_;
+      using CircuitComponent<ScalarT, IdxT>::time_;
+      using CircuitComponent<ScalarT, IdxT>::alpha_;
+      using CircuitComponent<ScalarT, IdxT>::y_ext_;
+      using CircuitComponent<ScalarT, IdxT>::y_int_;
+      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
+      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using CircuitComponent<ScalarT, IdxT>::tag_;
+      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
+      using CircuitComponent<ScalarT, IdxT>::f_ext_;
+      using CircuitComponent<ScalarT, IdxT>::f_int_;
+      using CircuitComponent<ScalarT, IdxT>::g_;
+      using CircuitComponent<ScalarT, IdxT>::yB_;
+      using CircuitComponent<ScalarT, IdxT>::ypB_;
+      using CircuitComponent<ScalarT, IdxT>::fB_;
+      using CircuitComponent<ScalarT, IdxT>::gB_;
+      using CircuitComponent<ScalarT, IdxT>::param_;
+      using CircuitComponent<ScalarT, IdxT>::idc_;
 
-    using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-    using CircuitComponent<ScalarT, IdxT>::n_extern_;
-    using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
+      using CircuitComponent<ScalarT, IdxT>::n_extern_;
+      using CircuitComponent<ScalarT, IdxT>::n_intern_;
 
-  public:
-    VoltageSource(IdxT id, RealT V, NodeT* node1, NodeT* node2);
-    virtual ~VoltageSource();
+    public:
+      VoltageSource(IdxT id, RealT V, NodeT* node1, NodeT* node2);
+      virtual ~VoltageSource();
 
-    int initialize();
-    int allocate() final;
-    int tagDifferentiable();
-    int setAbsoluteTolerance(RealT);
-    int evaluateInternalResidual() final;
-    int evaluateExternalResidual() final;
-    int evaluateJacobian() final;
-    int evaluateIntegrand();
+      int initialize();
+      int allocate() final;
+      int tagDifferentiable();
+      int setAbsoluteTolerance(RealT);
+      int evaluateInternalResidual() final;
+      int evaluateExternalResidual() final;
+      int evaluateJacobian() final;
+      int evaluateIntegrand();
 
-    int initializeAdjoint();
-    int evaluateAdjointResidual();
-    // int evaluateAdjointJacobian();
-    int evaluateAdjointIntegrand();
+      int initializeAdjoint();
+      int evaluateAdjointResidual();
+      // int evaluateAdjointJacobian();
+      int evaluateAdjointIntegrand();
 
-    CircuitComponent<ScalarT, IdxT>* clone() const;
+      CircuitComponent<ScalarT, IdxT>* clone() const;
 
-  private:
-    RealT  V_;
-    NodeT* node1_;
-    NodeT* node2_;
-  };
+    private:
+      RealT  V_;
+      NodeT* node1_;
+      NodeT* node2_;
+    };
+  } // namespace PowerElectronics
 } // namespace GridKit
diff --git a/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp b/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp
index 649146bab..6b15f19a6 100644
--- a/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp
+++ b/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp
@@ -22,7 +22,7 @@
 int main(int /* argc */, char const** /* argv */)
 {
 
-  GridKit::DistributedGeneratorParameters<double, size_t> parms;
+  GridKit::PowerElectronics::DistributedGeneratorParameters<double, size_t> parms;
   // Parameters from MATLAB Microgrid code for first DG
   parms.wb_  = 2.0 * std::numbers::pi_v<double> * 50.0;
   parms.wc_  = 31.41;
@@ -46,7 +46,7 @@ int main(int /* argc */, char const** /* argv */)
   using Bus = GridKit::PowerElectronics::MicrogridBus<double, size_t>;
   Bus bus;
 
-  GridKit::DistributedGenerator<double, size_t> dg(0, parms, false, &dg_signal, &bus);
+  GridKit::PowerElectronics::DistributedGenerator<double, size_t> dg(0, parms, false, &dg_signal, &bus);
 
   std::vector<double> t1(16, 0.0);
   std::vector<double> t2{
@@ -79,7 +79,7 @@ int main(int /* argc */, char const** /* argv */)
 
   for (size_t idx : dg.getExternIndices())
   {
-    GridKit::ExternalConnection<double, size_t> connection{
+    GridKit::PowerElectronics::ExternalConnection<double, size_t> connection{
         .y_   = &t2[idx],
         .yp_  = &t1[idx],
         .f_   = &res[idx],
diff --git a/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp b/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp
index 4a543e7d7..9f9e2fa4a 100644
--- a/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp
+++ b/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp
@@ -27,11 +27,11 @@ struct ScaleMicrogridNetwork
 
   using SignalNode  = GridKit::PowerElectronics::SignalNode<ScalarT, IdxT>;
   using Bus         = GridKit::PowerElectronics::MicrogridBus<ScalarT, IdxT>;
-  using BusDQ       = GridKit::MicrogridBusDQ<ScalarT, IdxT>;
-  using DGGenerator = GridKit::DistributedGenerator<ScalarT, IdxT>;
-  using Line        = GridKit::MicrogridLine<ScalarT, IdxT>;
-  using Load        = GridKit::MicrogridLoad<ScalarT, IdxT>;
-  using GenParams   = GridKit::DistributedGeneratorParameters<ScalarT, IdxT>;
+  using BusDQ       = GridKit::PowerElectronics::MicrogridBusDQ<ScalarT, IdxT>;
+  using DGGenerator = GridKit::PowerElectronics::DistributedGenerator<ScalarT, IdxT>;
+  using Line        = GridKit::PowerElectronics::MicrogridLine<ScalarT, IdxT>;
+  using Load        = GridKit::PowerElectronics::MicrogridLoad<ScalarT, IdxT>;
+  using GenParams   = GridKit::PowerElectronics::DistributedGeneratorParameters<ScalarT, IdxT>;
 
   size_t                    model_id_next;
   size_t                    N_size;
diff --git a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
index 3565ed63d..e77d82c6d 100644
--- a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
+++ b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
@@ -32,7 +32,9 @@
  *       does not call PowerElectronicsModel::allocate().
  */
 template <class ScalarT, typename IdxT>
-void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>& network, GridKit::PowerElectronicsModel<ScalarT, IdxT>& sys_model)
+void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>& network, 
+                    GridKit::PowerElectronics::PowerElectronicsModel<ScalarT, 
+                    IdxT>& sys_model)
 {
   size_t N_size = network.N_size;
 
diff --git a/examples/PowerElectronics/Microgrid/Microgrid.cpp b/examples/PowerElectronics/Microgrid/Microgrid.cpp
index 7dbe48096..e365faded 100644
--- a/examples/PowerElectronics/Microgrid/Microgrid.cpp
+++ b/examples/PowerElectronics/Microgrid/Microgrid.cpp
@@ -19,7 +19,7 @@ int main(int /* argc */, char const** /* argv */)
   bool   debug_output    = true;
 
   // Create model
-  auto* sysmodel = new GridKit::PowerElectronicsModel<double, size_t>(use_jac);
+  auto* sysmodel = new GridKit::PowerElectronics::PowerElectronicsModel<double, size_t>(use_jac);
 
   // Build the four-generator microgrid network.
   size_t                                N_size = 2;
diff --git a/examples/PowerElectronics/RLCircuit/RLCircuit.cpp b/examples/PowerElectronics/RLCircuit/RLCircuit.cpp
index a802d84c9..07db313ee 100644
--- a/examples/PowerElectronics/RLCircuit/RLCircuit.cpp
+++ b/examples/PowerElectronics/RLCircuit/RLCircuit.cpp
@@ -1,5 +1,4 @@
 
-
 #include <cmath>
 #include <iostream>
 
@@ -21,7 +20,7 @@ int main(int /* argc */, char const** /* argv */)
 
   // TODO:setup as named parameters
   // Create circuit model
-  GridKit::PowerElectronicsModel<double, size_t> sysmodel(use_jac);
+  GridKit::PowerElectronics::PowerElectronicsModel<double, size_t> sysmodel(use_jac);
 
   size_t idoff = 0;
 
@@ -41,17 +40,17 @@ int main(int /* argc */, char const** /* argv */)
   sysmodel.addNode(&bus_ir);
 
   // inductor
-  GridKit::Inductor<double, size_t>* induct = new GridKit::Inductor<double, size_t>(idoff, linit, &bus_ir, &bus_iv);
+  auto* induct = new GridKit::PowerElectronics::Inductor<double, size_t>(idoff, linit, &bus_ir, &bus_iv);
   sysmodel.addComponent(induct);
 
   // resistor
   idoff++;
-  GridKit::Resistor<double, size_t>* resis = new GridKit::Resistor<double, size_t>(idoff, rinit, &bus_vr, &bus_ir);
+  auto* resis = new GridKit::PowerElectronics::Resistor<double, size_t>(idoff, rinit, &bus_vr, &bus_ir);
   sysmodel.addComponent(resis);
 
   // voltage source
   idoff++;
-  GridKit::VoltageSource<double, size_t>* vsource = new GridKit::VoltageSource<double, size_t>(idoff, vinit, &bus_iv, &bus_vr);
+  auto* vsource = new GridKit::PowerElectronics::VoltageSource<double, size_t>(idoff, vinit, &bus_iv, &bus_vr);
   sysmodel.addComponent(vsource);
 
   sysmodel.allocate();
diff --git a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp
index 4c689cbc8..9b3fc3836 100644
--- a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp
+++ b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp
@@ -56,7 +56,7 @@ int main(int /* argc */, char const** /* argv */)
  */
 int test(index_type Nsize, real_type error_tol, bool debug_output)
 {
-  using namespace GridKit;
+  using namespace GridKit::PowerElectronics;
 
   bool use_jac = true;
 
diff --git a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp
index 1edc577e2..6ac49f16a 100644
--- a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp
+++ b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp
@@ -55,7 +55,7 @@ int main(int argc, char const* argv[])
  */
 int printMicrogridSystems(index_type N_size)
 {
-  using namespace GridKit;
+  using namespace GridKit::PowerElectronics;
 
   bool use_jac = true;
 
diff --git a/tests/UnitTests/PowerElectronics/CircuitNodeTests.hpp b/tests/UnitTests/PowerElectronics/CircuitNodeTests.hpp
index bc380f972..eb8574f3c 100644
--- a/tests/UnitTests/PowerElectronics/CircuitNodeTests.hpp
+++ b/tests/UnitTests/PowerElectronics/CircuitNodeTests.hpp
@@ -24,10 +24,10 @@ namespace GridKit
 
         ScalarT V{1.0};
 
-        CircuitNode<ScalarT, IdxT>* node = nullptr;
+        PowerElectronics::CircuitNode<ScalarT, IdxT>* node = nullptr;
 
         // Default construct
-        node = new CircuitNode<ScalarT, IdxT>();
+        node = new PowerElectronics::CircuitNode<ScalarT, IdxT>();
         node->allocate();
         node->initialize();
         success *= isEqual(node->V(), static_cast<ScalarT>(0));
@@ -35,11 +35,12 @@ namespace GridKit
         delete node;
 
         // Construct with initial voltage
-        node = new CircuitNode<ScalarT, IdxT>(V);
+        node = new PowerElectronics::CircuitNode<ScalarT, IdxT>(V);
         node->allocate();
         node->initialize();
         success *= isEqual(node->V(), V);
         success *= isEqual(node->I(), static_cast<ScalarT>(0));
+
         delete node;
 
         node = nullptr;
@@ -55,7 +56,7 @@ namespace GridKit
         ScalarT V{1.0};
         ScalarT I{1.0};
 
-        CircuitNode<ScalarT, IdxT> node(V);
+        PowerElectronics::CircuitNode<ScalarT, IdxT> node(V);
         node.allocate();
         node.initialize();
         success *= isEqual(node.V(), V);
diff --git a/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp b/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp
index 77ea9a623..cf9492f34 100644
--- a/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp
+++ b/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp
@@ -17,11 +17,11 @@ namespace GridKit
     {
       using SignalNode          = PowerElectronics::SignalNode<ScalarT, IdxT>;
       using Bus                 = PowerElectronics::MicrogridBus<ScalarT, IdxT>;
-      using BusDQ               = MicrogridBusDQ<ScalarT, IdxT>;
-      using Generator           = DistributedGenerator<ScalarT, IdxT>;
-      using GeneratorParameters = DistributedGeneratorParameters<ScalarT, IdxT>;
-      using Line                = MicrogridLine<ScalarT, IdxT>;
-      using Load                = MicrogridLoad<ScalarT, IdxT>;
+      using BusDQ               = PowerElectronics::MicrogridBusDQ<ScalarT, IdxT>;
+      using Generator           = PowerElectronics::DistributedGenerator<ScalarT, IdxT>;
+      using GeneratorParameters = PowerElectronics::DistributedGeneratorParameters<ScalarT, IdxT>;
+      using Line                = PowerElectronics::MicrogridLine<ScalarT, IdxT>;
+      using Load                = PowerElectronics::MicrogridLoad<ScalarT, IdxT>;
 
     public:
       CircuitComponentCloneTests()
@@ -125,7 +125,7 @@ namespace GridKit
       template <typename ComponentT>
       bool verifyComponentClone(ComponentT& component)
       {
-        using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+        using RealT = typename PowerElectronics::CircuitComponent<ScalarT, IdxT>::RealT;
 
         bool success = true;
 

From 27460d124ce3e18b0ff975967ead5a90734a26b4 Mon Sep 17 00:00:00 2001
From: Nicholson Koukpaizan <koukpaizannk@ornl.gov>
Date: Thu, 10 Sep 2026 15:52:04 -0400
Subject: [PATCH 2/6] Drop Circuit... from PowerElectronics names. Namespace is
 sufficient.

---
 GridKit/Model/PowerElectronics/CMakeLists.txt |  6 +-
 .../PowerElectronics/Capacitor/Capacitor.cpp  |  2 +-
 .../PowerElectronics/Capacitor/Capacitor.hpp  | 52 ++++++++--------
 .../{CircuitComponent.hpp => Component.hpp}   | 14 ++---
 .../DistributedGenerator.cpp                  |  4 +-
 .../DistributedGenerator.hpp                  | 52 ++++++++--------
 .../PowerElectronics/ExternalConnection.hpp   | 10 ++--
 .../InductionMotor/InductionMotor.cpp         |  2 +-
 .../InductionMotor/InductionMotor.hpp         | 52 ++++++++--------
 .../{CircuitNode.hpp => Node.hpp}             |  8 +--
 GridKit/Model/PowerElectronics/NodeBase.hpp   |  2 +-
 ...elPowerElectronics.hpp => SystemModel.hpp} | 60 +++++++++----------
 12 files changed, 132 insertions(+), 132 deletions(-)
 rename GridKit/Model/PowerElectronics/{CircuitComponent.hpp => Component.hpp} (98%)
 rename GridKit/Model/PowerElectronics/{CircuitNode.hpp => Node.hpp} (97%)
 rename GridKit/Model/PowerElectronics/{SystemModelPowerElectronics.hpp => SystemModel.hpp} (89%)

diff --git a/GridKit/Model/PowerElectronics/CMakeLists.txt b/GridKit/Model/PowerElectronics/CMakeLists.txt
index e606e1be8..66c058cfa 100644
--- a/GridKit/Model/PowerElectronics/CMakeLists.txt
+++ b/GridKit/Model/PowerElectronics/CMakeLists.txt
@@ -23,9 +23,9 @@ add_subdirectory(MicrogridLine)
 add_subdirectory(MicrogridBusDQ)
 
 install(
-  FILES CircuitComponent.hpp
-        CircuitNode.hpp
-        SystemModelPowerElectronics.hpp
+  FILES Component.hpp
+        Node.hpp
+        SystemModel.hpp
         NodeBase.hpp
         ExternalConnection.hpp
   DESTINATION include/GridKit/Model/PowerElectronics)
diff --git a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp
index 414fbb5d9..1fe6e1907 100644
--- a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp
+++ b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.cpp
@@ -138,7 +138,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* Capacitor<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* Capacitor<ScalarT, IdxT>::clone() const
     {
       return new Capacitor<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp
index 009888882..79f58e5b7 100644
--- a/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp
+++ b/GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 
 namespace GridKit
 {
@@ -12,33 +12,33 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class Capacitor : public CircuitComponent<ScalarT, IdxT>
+    class Capacitor : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       Capacitor(IdxT id, RealT C);
@@ -57,7 +57,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT C_;
diff --git a/GridKit/Model/PowerElectronics/CircuitComponent.hpp b/GridKit/Model/PowerElectronics/Component.hpp
similarity index 98%
rename from GridKit/Model/PowerElectronics/CircuitComponent.hpp
rename to GridKit/Model/PowerElectronics/Component.hpp
index bed8a983e..28b54f86a 100644
--- a/GridKit/Model/PowerElectronics/CircuitComponent.hpp
+++ b/GridKit/Model/PowerElectronics/Component.hpp
@@ -16,18 +16,18 @@ namespace GridKit
   namespace PowerElectronics
   {
     /*!
-     * @brief Declaration of a CircuitComponent class.
+     * @brief Declaration of a Component class.
      *
      */
     template <class ScalarT, typename IdxT>
-    class CircuitComponent : public Model::Evaluator<ScalarT, IdxT>
+    class Component : public Model::Evaluator<ScalarT, IdxT>
     {
     public:
       using RealT      = typename Model::Evaluator<ScalarT, IdxT>::RealT;
       using CsrMatrixT = typename Model::Evaluator<ScalarT, IdxT>::CsrMatrixT;
       using VectorT    = typename Model::Evaluator<ScalarT, IdxT>::VectorT;
 
-      CircuitComponent() = default;
+      Component() = default;
 
     protected:
       /**
@@ -55,7 +55,7 @@ namespace GridKit
        *       system, its state, state-derivative, and residual pointers must be
        *       reassigned to the storage provided by that system before evaluation.
        */
-      CircuitComponent(const CircuitComponent& other)
+      Component(const Component& other)
         : n_extern_(other.n_extern_),
           n_intern_(other.n_intern_),
           extern_indices_(other.extern_indices_),
@@ -181,7 +181,7 @@ namespace GridKit
        * residual pointers are not set. The user is responsible for setting these
        * pointers to the appropriate storage before evaluating the residual.
        */
-      virtual CircuitComponent<ScalarT, IdxT>* clone() const
+      virtual Component<ScalarT, IdxT>* clone() const
       {
         throw std::runtime_error("clone() is not supported for this component.");
       }
@@ -369,8 +369,8 @@ namespace GridKit
       }
 
       /**
-       * @brief Evaluating the residual of a CircuitComponent should be done by evaluating the
-       * internal residuals and external residuals. CircuitComponents should overload those
+       * @brief Evaluating the residual of a Component should be done by evaluating the
+       * internal residuals and external residuals. Components should overload those
        * functions for their residuals (and the system will call those function instead of this one),
        * so there is no reason to overload this functionality.
        *
diff --git a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp
index 5b0c6967b..44f7914da 100644
--- a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp
+++ b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.cpp
@@ -389,7 +389,7 @@ namespace GridKit
     template <class ScalarT, typename IdxT>
     int DistributedGenerator<ScalarT, IdxT>::allocate()
     {
-      CircuitComponent<ScalarT, IdxT>::allocate();
+      Component<ScalarT, IdxT>::allocate();
 
       this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
       this->setExternalConnectionNodes(1, node_bus_->getNodeConnection(0));
@@ -423,7 +423,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* DistributedGenerator<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* DistributedGenerator<ScalarT, IdxT>::clone() const
     {
       return new DistributedGenerator<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp
index b67ff2b98..eb667d67d 100644
--- a/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp
+++ b/GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 
 namespace GridKit
@@ -37,34 +37,34 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class DistributedGenerator : public CircuitComponent<ScalarT, IdxT>
+    class DistributedGenerator : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
       using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       DistributedGenerator(IdxT                                        id,
@@ -87,7 +87,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT wb_;
diff --git a/GridKit/Model/PowerElectronics/ExternalConnection.hpp b/GridKit/Model/PowerElectronics/ExternalConnection.hpp
index 2cc6a1e27..f0a3322cd 100644
--- a/GridKit/Model/PowerElectronics/ExternalConnection.hpp
+++ b/GridKit/Model/PowerElectronics/ExternalConnection.hpp
@@ -8,18 +8,18 @@ namespace GridKit
      * @brief The connection of a component's external variable to its system.
      * Allows the component to access data about that external variable and allows
      * the system to construct Jacobian information about that variable.
-     * @see CircuitComponent::setExternalConnectionNodes()
+     * @see Component::setExternalConnectionNodes()
      */
     template <class ScalarT, typename IdxT>
     struct ExternalConnection
     {
-      /// A pointer to the state value of the variable. \see CircuitComponent::y_ext_
+      /// A pointer to the state value of the variable. \see Component::y_ext_
       const ScalarT* y_;
-      /// A pointer to the derivative value of the variable. \see CircuitComponent::yp_ext_
+      /// A pointer to the derivative value of the variable. \see Component::yp_ext_
       const ScalarT* yp_;
-      /// A pointer to the residual buffer of the variable. \see CircuitComponent::f_ext_
+      /// A pointer to the residual buffer of the variable. \see Component::f_ext_
       ScalarT*       f_;
-      /// The corresponding system variable index. \see CircuitComponent::connection_nodes_
+      /// The corresponding system variable index. \see Component::connection_nodes_
       IdxT           idx_;
     };
   } // namespace PowerElectronics
diff --git a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp
index dd2f00851..41c5c7b40 100644
--- a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp
+++ b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.cpp
@@ -150,7 +150,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* InductionMotor<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* InductionMotor<ScalarT, IdxT>::clone() const
     {
       return new InductionMotor<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp
index d68866010..a79e1ffa8 100644
--- a/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp
+++ b/GridKit/Model/PowerElectronics/InductionMotor/InductionMotor.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 
 namespace GridKit
 {
@@ -12,33 +12,33 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class InductionMotor : public CircuitComponent<ScalarT, IdxT>
+    class InductionMotor : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       InductionMotor(IdxT id, RealT Lls, RealT Rs, RealT Llr, RealT Rr, RealT Lms, RealT RJ, RealT P);
@@ -57,7 +57,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT Lls_;
diff --git a/GridKit/Model/PowerElectronics/CircuitNode.hpp b/GridKit/Model/PowerElectronics/Node.hpp
similarity index 97%
rename from GridKit/Model/PowerElectronics/CircuitNode.hpp
rename to GridKit/Model/PowerElectronics/Node.hpp
index 176e5f7d7..c9cd1b57b 100644
--- a/GridKit/Model/PowerElectronics/CircuitNode.hpp
+++ b/GridKit/Model/PowerElectronics/Node.hpp
@@ -15,24 +15,24 @@ namespace GridKit
      * @brief Circuit node representing a connection point.
      */
     template <typename ScalarT, typename IdxT>
-    class CircuitNode : public Model::Evaluator<ScalarT, IdxT>
+    class Node : public Model::Evaluator<ScalarT, IdxT>
     {
       using RealT   = typename Model::Evaluator<ScalarT, IdxT>::RealT;
       using VectorT = typename Model::Evaluator<ScalarT, IdxT>::VectorT;
 
     public:
-      CircuitNode()
+      Node()
       {
         size_ = 1;
       }
 
-      CircuitNode(ScalarT v0)
+      Node(ScalarT v0)
         : V0_(v0)
       {
         size_ = 1;
       }
 
-      ~CircuitNode() = default;
+      ~Node() = default;
 
       int setNodeID(IdxT id)
       {
diff --git a/GridKit/Model/PowerElectronics/NodeBase.hpp b/GridKit/Model/PowerElectronics/NodeBase.hpp
index b39539781..6e95322f1 100644
--- a/GridKit/Model/PowerElectronics/NodeBase.hpp
+++ b/GridKit/Model/PowerElectronics/NodeBase.hpp
@@ -104,7 +104,7 @@ namespace GridKit
 
       /**
        * @brief Create the mappings from local to global indices for a node variable (either internal or external),
-       * to be used from an attached component. \see CircuitComponent::setExternalConnectionNodes()
+       * to be used from an attached component. \see Component::setExternalConnectionNodes()
        *
        * @param local_index The index of the local variable
        * @param connection The necessary connection information for the variable
diff --git a/GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp b/GridKit/Model/PowerElectronics/SystemModel.hpp
similarity index 89%
rename from GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp
rename to GridKit/Model/PowerElectronics/SystemModel.hpp
index 8cc3c1402..c3a997b9c 100644
--- a/GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp
+++ b/GridKit/Model/PowerElectronics/SystemModel.hpp
@@ -6,8 +6,8 @@
 #include <vector>
 
 #include <GridKit/Constants.hpp>
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
-#include <GridKit/Model/PowerElectronics/CircuitNode.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
+#include <GridKit/Model/PowerElectronics/Node.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 #include <GridKit/ScalarTraits.hpp>
 
@@ -16,29 +16,29 @@ namespace GridKit
   namespace PowerElectronics
   {
     template <class ScalarT, typename IdxT>
-    class PowerElectronicsModel : public CircuitComponent<ScalarT, IdxT>
+    class SystemModel : public Component<ScalarT, IdxT>
     {
-      using RealT          = typename CircuitComponent<ScalarT, IdxT>::RealT;
-      using CsrMatrixT     = typename CircuitComponent<ScalarT, IdxT>::CsrMatrixT;
-      using component_type = CircuitComponent<ScalarT, IdxT>;
-      using node_type      = PowerElectronics::NodeBase<ScalarT, IdxT>;
-
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::allocated_;
-      using CircuitComponent<ScalarT, IdxT>::allocateVectors;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
+      using RealT          = typename Component<ScalarT, IdxT>::RealT;
+      using CsrMatrixT     = typename Component<ScalarT, IdxT>::CsrMatrixT;
+      using component_type = Component<ScalarT, IdxT>;
+      using node_type      = NodeBase<ScalarT, IdxT>;
+
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::allocated_;
+      using Component<ScalarT, IdxT>::allocateVectors;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
 
     public:
       /**
@@ -46,7 +46,7 @@ namespace GridKit
        *
        * @post System model parameters set as default
        */
-      PowerElectronicsModel()
+      SystemModel()
       {
         // By default don't use the jacobian
         use_jac_ = false;
@@ -59,7 +59,7 @@ namespace GridKit
        *
        * @post System model parameters set as input
        */
-      PowerElectronicsModel(bool use_jac = false)
+      SystemModel(bool use_jac = false)
       {
         // Can choose if to use jacobian
         use_jac_ = use_jac;
@@ -73,7 +73,7 @@ namespace GridKit
        * @post System components are deallocated
        *
        */
-      virtual ~PowerElectronicsModel()
+      virtual ~SystemModel()
       {
         for (auto comp : this->components_)
         {
@@ -111,7 +111,7 @@ namespace GridKit
        * @post System model vectors allocated with the computed total number of unknowns
        * @post CSR Jacobian sparsity pattern is computed
        * @post COO->CSR mapping is computed
-       * @post Every component's \ref CircuitComponent::y_int_, \ref CircuitComponent::yp_int_, and \ref CircuitComponent::f_int_ pointers
+       * @post Every component's \ref Component::y_int_, \ref Component::yp_int_, and \ref Component::f_int_ pointers
        * are set to their appropriate offsets in the system vector, allowing them to directly access their internal variables, derivatives,
        * and residuals.
        *
@@ -290,7 +290,7 @@ namespace GridKit
           component->initialize();
         }
 
-        return CircuitComponent<ScalarT, IdxT>::initialize();
+        return Component<ScalarT, IdxT>::initialize();
       }
 
       /**
@@ -527,6 +527,6 @@ namespace GridKit
       int  jac_call_count_{0};
       bool use_jac_;
 
-    }; // class PowerElectronicsModel
+    }; // class SystemModel
   } // namespace PowerElectronics
 } // namespace GridKit

From a884f8803f628d12951648cd32bc53fc14eea0b2 Mon Sep 17 00:00:00 2001
From: Nicholson Koukpaizan <koukpaizannk@ornl.gov>
Date: Thu, 10 Sep 2026 16:08:58 -0400
Subject: [PATCH 3/6] Simplify PowerElectronics class names.

---
 GridKit/Model/PowerElectronics/Component.hpp  |  2 +-
 .../PowerElectronics/Inductor/Inductor.cpp    |  4 +-
 .../PowerElectronics/Inductor/Inductor.hpp    | 52 +++++++++----------
 .../LinearTransformer/LinearTransformer.cpp   |  2 +-
 .../LinearTransformer/LinearTransformer.hpp   | 52 +++++++++----------
 .../MicrogridBusDQ/MicrogridBusDQ.cpp         |  4 +-
 .../MicrogridBusDQ/MicrogridBusDQ.hpp         | 52 +++++++++----------
 .../MicrogridLine/MicrogridLine.cpp           |  4 +-
 .../MicrogridLine/MicrogridLine.hpp           | 52 +++++++++----------
 .../MicrogridLoad/MicrogridLoad.cpp           |  4 +-
 .../MicrogridLoad/MicrogridLoad.hpp           | 52 +++++++++----------
 GridKit/Model/PowerElectronics/README.md      |  2 +-
 .../PowerElectronics/Resistor/Resistor.cpp    |  4 +-
 .../PowerElectronics/Resistor/Resistor.hpp    | 52 +++++++++----------
 .../SynchronousMachine/SynchronousMachine.cpp |  2 +-
 .../SynchronousMachine/SynchronousMachine.hpp | 52 +++++++++----------
 .../TransmissionLine/TransmissionLine.cpp     |  2 +-
 .../TransmissionLine/TransmissionLine.hpp     | 52 +++++++++----------
 .../VoltageSource/VoltageSource.cpp           |  4 +-
 .../VoltageSource/VoltageSource.hpp           | 52 +++++++++----------
 .../DistributedGeneratorTest/DGTest.cpp       |  2 +-
 .../ExamplesHelper/MicrogridNetwork.hpp       |  2 +-
 .../ExamplesHelper/SystemAssembler.hpp        |  4 +-
 .../PowerElectronics/Microgrid/Microgrid.cpp  |  4 +-
 .../PowerElectronics/RLCircuit/RLCircuit.cpp  |  4 +-
 .../ScaleMicrogrid/ScaleMicrogrid.cpp         |  4 +-
 .../ScaleMicrogridArbitrary.cpp               |  2 +-
 .../UnitTests/PowerElectronics/CMakeLists.txt |  2 +-
 .../PowerElectronics/ComponentCloneTests.hpp  |  8 +--
 .../{CircuitNodeTests.hpp => NodeTests.hpp}   | 10 ++--
 .../runComponentCloneTests.cpp                |  2 +-
 ...nCircuitNodeTests.cpp => runNodeTests.cpp} |  2 +-
 32 files changed, 274 insertions(+), 274 deletions(-)
 rename tests/UnitTests/PowerElectronics/{CircuitNodeTests.hpp => NodeTests.hpp} (82%)
 rename tests/UnitTests/PowerElectronics/{runCircuitNodeTests.cpp => runNodeTests.cpp} (86%)

diff --git a/GridKit/Model/PowerElectronics/Component.hpp b/GridKit/Model/PowerElectronics/Component.hpp
index 28b54f86a..aa7c5c715 100644
--- a/GridKit/Model/PowerElectronics/Component.hpp
+++ b/GridKit/Model/PowerElectronics/Component.hpp
@@ -685,7 +685,7 @@ namespace GridKit
       std::set<IdxT>          extern_indices_;
       /**
        * @brief A map from local variable indices to system (global) variable indices. Used for Jacobian construction in
-       * \ref PowerElectronicsModel::evaluateJacobian().
+       * \ref PowerElectronics::SystemModel::evaluateJacobian().
        * @note If a variable does not map to a corresponding variable in the system (such as with reference nodes), a special
        * sentinel value of \ref INVALID_INDEX is used. During Jacobian construction, such rows and columns will be pruned.
        */
diff --git a/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp b/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp
index 2e38e35de..2d367b608 100644
--- a/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp
+++ b/GridKit/Model/PowerElectronics/Inductor/Inductor.cpp
@@ -116,7 +116,7 @@ namespace GridKit
     template <class ScalarT, typename IdxT>
     int Inductor<ScalarT, IdxT>::allocate()
     {
-      CircuitComponent<ScalarT, IdxT>::allocate();
+      Component<ScalarT, IdxT>::allocate();
 
       this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
       this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
@@ -149,7 +149,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* Inductor<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* Inductor<ScalarT, IdxT>::clone() const
     {
       return new Inductor<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp b/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp
index fb69dc871..1b4a5f07f 100644
--- a/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp
+++ b/GridKit/Model/PowerElectronics/Inductor/Inductor.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 
 namespace GridKit
@@ -13,34 +13,34 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class Inductor : public CircuitComponent<ScalarT, IdxT>
+    class Inductor : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
       using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       Inductor(IdxT id, RealT L, NodeT* node1, NodeT* node2);
@@ -60,7 +60,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT  L_;
diff --git a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp
index 3a8cc282a..9e33b79c2 100644
--- a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp
+++ b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.cpp
@@ -135,7 +135,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* LinearTransformer<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* LinearTransformer<ScalarT, IdxT>::clone() const
     {
       return new LinearTransformer<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp
index 047ed0fe4..11ed78dd4 100644
--- a/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp
+++ b/GridKit/Model/PowerElectronics/LinearTransformer/LinearTransformer.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 
 namespace GridKit
 {
@@ -12,33 +12,33 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class LinearTransformer : public CircuitComponent<ScalarT, IdxT>
+    class LinearTransformer : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       LinearTransformer(IdxT id, RealT L0, RealT L1, RealT R0, RealT R1, RealT M);
@@ -57,7 +57,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT L0_;
diff --git a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp
index 95d20b8e8..fec34aa9c 100644
--- a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp
+++ b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.cpp
@@ -121,7 +121,7 @@ namespace GridKit
     template <class ScalarT, typename IdxT>
     int MicrogridBusDQ<ScalarT, IdxT>::allocate()
     {
-      CircuitComponent<ScalarT, IdxT>::allocate();
+      Component<ScalarT, IdxT>::allocate();
 
       this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
       this->setExternalConnectionNodes(1, node1_->getNodeConnection(1));
@@ -154,7 +154,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* MicrogridBusDQ<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* MicrogridBusDQ<ScalarT, IdxT>::clone() const
     {
       return new MicrogridBusDQ<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp
index e1d44fce1..8ba4cf6de 100644
--- a/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp
+++ b/GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 
 namespace GridKit
@@ -13,34 +13,34 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class MicrogridBusDQ : public CircuitComponent<ScalarT, IdxT>
+    class MicrogridBusDQ : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
       using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       MicrogridBusDQ(IdxT id, RealT RN, NodeT* node1);
@@ -60,7 +60,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT  RN_;
diff --git a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp
index 746ed2d54..4ac28f489 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.cpp
@@ -149,7 +149,7 @@ namespace GridKit
     template <class ScalarT, typename IdxT>
     int MicrogridLine<ScalarT, IdxT>::allocate()
     {
-      CircuitComponent<ScalarT, IdxT>::allocate();
+      Component<ScalarT, IdxT>::allocate();
 
       this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
       this->setExternalConnectionNodes(1, bus1_->getNodeConnection(0));
@@ -185,7 +185,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* MicrogridLine<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* MicrogridLine<ScalarT, IdxT>::clone() const
     {
       return new MicrogridLine<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp
index 38fcc81ab..dd520cb45 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 
 namespace GridKit
@@ -13,34 +13,34 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class MicrogridLine : public CircuitComponent<ScalarT, IdxT>
+    class MicrogridLine : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
       using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       MicrogridLine(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* bus1, NodeT* bus2);
@@ -60,7 +60,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT  R_;
diff --git a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp
index 2fed49932..1d0e07f63 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.cpp
@@ -142,7 +142,7 @@ namespace GridKit
     template <class ScalarT, typename IdxT>
     int MicrogridLoad<ScalarT, IdxT>::allocate()
     {
-      CircuitComponent<ScalarT, IdxT>::allocate();
+      Component<ScalarT, IdxT>::allocate();
 
       this->setExternalConnectionNodes(0, node_ref_->getNodeConnection(0));
       this->setExternalConnectionNodes(1, node_bus_->getNodeConnection(0));
@@ -176,7 +176,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* MicrogridLoad<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* MicrogridLoad<ScalarT, IdxT>::clone() const
     {
       return new MicrogridLoad<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp
index c36468004..b5759d609 100644
--- a/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp
+++ b/GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 
 namespace GridKit
@@ -13,34 +13,34 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class MicrogridLoad : public CircuitComponent<ScalarT, IdxT>
+    class MicrogridLoad : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
       using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       MicrogridLoad(IdxT id, RealT R, RealT L, NodeT* node_ref, NodeT* node_bus);
@@ -60,7 +60,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT  R_;
diff --git a/GridKit/Model/PowerElectronics/README.md b/GridKit/Model/PowerElectronics/README.md
index 669e82172..c4f88acec 100644
--- a/GridKit/Model/PowerElectronics/README.md
+++ b/GridKit/Model/PowerElectronics/README.md
@@ -1,4 +1,4 @@
-This sub-directory provides components utilized within the PowerElectronicsModel composer. All components are treated equally and only the composer can view and distribute data to components. Components have no knowledge nor require the existence of any other component.
+This sub-directory provides components utilized within the PowerElectronics::SystemModel composer. All components are treated equally and only the composer can view and distribute data to components. Components have no knowledge nor require the existence of any other component.
 Each component evaluates a set of equations to form residuals. There are two types of variables.
  + Internal Variables $y$. Variables only need by the component.
  + External Variables $w$. Variables shared between multiple components.
diff --git a/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp b/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp
index b4d0c24a9..0284bafaf 100644
--- a/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp
+++ b/GridKit/Model/PowerElectronics/Resistor/Resistor.cpp
@@ -106,7 +106,7 @@ namespace GridKit
     template <class ScalarT, typename IdxT>
     int Resistor<ScalarT, IdxT>::allocate()
     {
-      CircuitComponent<ScalarT, IdxT>::allocate();
+      Component<ScalarT, IdxT>::allocate();
 
       this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
       this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
@@ -139,7 +139,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* Resistor<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* Resistor<ScalarT, IdxT>::clone() const
     {
       return new Resistor<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp b/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp
index 19a8600a8..0be29459e 100644
--- a/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp
+++ b/GridKit/Model/PowerElectronics/Resistor/Resistor.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 
 namespace GridKit
@@ -13,34 +13,34 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class Resistor : public CircuitComponent<ScalarT, IdxT>
+    class Resistor : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
       using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       Resistor(IdxT id, RealT R, NodeT* node1, NodeT* node2);
@@ -60,7 +60,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT  R_;
diff --git a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp
index 7497a9d06..f1e1f6d8d 100644
--- a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp
+++ b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.cpp
@@ -185,7 +185,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* SynchronousMachine<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* SynchronousMachine<ScalarT, IdxT>::clone() const
     {
       return new SynchronousMachine<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp
index 771364cbf..39c21072e 100644
--- a/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp
+++ b/GridKit/Model/PowerElectronics/SynchronousMachine/SynchronousMachine.hpp
@@ -3,7 +3,7 @@
 
 #include <tuple>
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 
 namespace GridKit
 {
@@ -14,33 +14,33 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class SynchronousMachine : public CircuitComponent<ScalarT, IdxT>
+    class SynchronousMachine : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       SynchronousMachine(IdxT id, RealT Lls, std::tuple<RealT, RealT> Llkq, RealT Llfd, RealT Llkd, RealT Lmq, RealT Lmd, RealT Rs, std::tuple<RealT, RealT> Rkq, RealT Rfd, RealT Rkd, RealT RJ, RealT P, RealT mub);
@@ -59,7 +59,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT                    Lls_;
diff --git a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp
index f5ea05cf7..cd120c2de 100644
--- a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp
+++ b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.cpp
@@ -206,7 +206,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* TransmissionLine<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* TransmissionLine<ScalarT, IdxT>::clone() const
     {
       return new TransmissionLine<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp
index 3166353d3..7a21c4bf7 100644
--- a/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp
+++ b/GridKit/Model/PowerElectronics/TransmissionLine/TransmissionLine.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 
 namespace GridKit
 {
@@ -22,33 +22,33 @@ namespace GridKit
      * @note Not used in the Microgrid model.
      */
     template <class ScalarT, typename IdxT>
-    class TransmissionLine : public CircuitComponent<ScalarT, IdxT>
+    class TransmissionLine : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       TransmissionLine(IdxT id, RealT R, RealT X, RealT B);
@@ -67,7 +67,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT R_;
diff --git a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp
index 66b207094..e29d13de4 100644
--- a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp
+++ b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.cpp
@@ -109,7 +109,7 @@ namespace GridKit
     template <class ScalarT, typename IdxT>
     int VoltageSource<ScalarT, IdxT>::allocate()
     {
-      CircuitComponent<ScalarT, IdxT>::allocate();
+      Component<ScalarT, IdxT>::allocate();
 
       this->setExternalConnectionNodes(0, node1_->getNodeConnection(0));
       this->setExternalConnectionNodes(1, node2_->getNodeConnection(0));
@@ -142,7 +142,7 @@ namespace GridKit
     }
 
     template <class ScalarT, typename IdxT>
-    CircuitComponent<ScalarT, IdxT>* VoltageSource<ScalarT, IdxT>::clone() const
+    Component<ScalarT, IdxT>* VoltageSource<ScalarT, IdxT>::clone() const
     {
       return new VoltageSource<ScalarT, IdxT>(*this);
     }
diff --git a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp
index d7ddda194..e80ce5008 100644
--- a/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp
+++ b/GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp
@@ -1,7 +1,7 @@
 
 #pragma once
 
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/NodeBase.hpp>
 
 namespace GridKit
@@ -13,34 +13,34 @@ namespace GridKit
      *
      */
     template <class ScalarT, typename IdxT>
-    class VoltageSource : public CircuitComponent<ScalarT, IdxT>
+    class VoltageSource : public Component<ScalarT, IdxT>
     {
-      using RealT = typename CircuitComponent<ScalarT, IdxT>::RealT;
+      using RealT = typename Component<ScalarT, IdxT>::RealT;
       using NodeT = typename PowerElectronics::NodeBase<ScalarT, IdxT>;
 
-      using CircuitComponent<ScalarT, IdxT>::size_;
-      using CircuitComponent<ScalarT, IdxT>::nnz_;
-      using CircuitComponent<ScalarT, IdxT>::time_;
-      using CircuitComponent<ScalarT, IdxT>::alpha_;
-      using CircuitComponent<ScalarT, IdxT>::y_ext_;
-      using CircuitComponent<ScalarT, IdxT>::y_int_;
-      using CircuitComponent<ScalarT, IdxT>::yp_ext_;
-      using CircuitComponent<ScalarT, IdxT>::yp_int_;
-      using CircuitComponent<ScalarT, IdxT>::tag_;
-      using CircuitComponent<ScalarT, IdxT>::abs_tol_;
-      using CircuitComponent<ScalarT, IdxT>::f_ext_;
-      using CircuitComponent<ScalarT, IdxT>::f_int_;
-      using CircuitComponent<ScalarT, IdxT>::g_;
-      using CircuitComponent<ScalarT, IdxT>::yB_;
-      using CircuitComponent<ScalarT, IdxT>::ypB_;
-      using CircuitComponent<ScalarT, IdxT>::fB_;
-      using CircuitComponent<ScalarT, IdxT>::gB_;
-      using CircuitComponent<ScalarT, IdxT>::param_;
-      using CircuitComponent<ScalarT, IdxT>::idc_;
+      using Component<ScalarT, IdxT>::size_;
+      using Component<ScalarT, IdxT>::nnz_;
+      using Component<ScalarT, IdxT>::time_;
+      using Component<ScalarT, IdxT>::alpha_;
+      using Component<ScalarT, IdxT>::y_ext_;
+      using Component<ScalarT, IdxT>::y_int_;
+      using Component<ScalarT, IdxT>::yp_ext_;
+      using Component<ScalarT, IdxT>::yp_int_;
+      using Component<ScalarT, IdxT>::tag_;
+      using Component<ScalarT, IdxT>::abs_tol_;
+      using Component<ScalarT, IdxT>::f_ext_;
+      using Component<ScalarT, IdxT>::f_int_;
+      using Component<ScalarT, IdxT>::g_;
+      using Component<ScalarT, IdxT>::yB_;
+      using Component<ScalarT, IdxT>::ypB_;
+      using Component<ScalarT, IdxT>::fB_;
+      using Component<ScalarT, IdxT>::gB_;
+      using Component<ScalarT, IdxT>::param_;
+      using Component<ScalarT, IdxT>::idc_;
 
-      using CircuitComponent<ScalarT, IdxT>::extern_indices_;
-      using CircuitComponent<ScalarT, IdxT>::n_extern_;
-      using CircuitComponent<ScalarT, IdxT>::n_intern_;
+      using Component<ScalarT, IdxT>::extern_indices_;
+      using Component<ScalarT, IdxT>::n_extern_;
+      using Component<ScalarT, IdxT>::n_intern_;
 
     public:
       VoltageSource(IdxT id, RealT V, NodeT* node1, NodeT* node2);
@@ -60,7 +60,7 @@ namespace GridKit
       // int evaluateAdjointJacobian();
       int evaluateAdjointIntegrand();
 
-      CircuitComponent<ScalarT, IdxT>* clone() const;
+      Component<ScalarT, IdxT>* clone() const;
 
     private:
       RealT  V_;
diff --git a/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp b/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp
index 6b15f19a6..7ee73f9de 100644
--- a/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp
+++ b/examples/PowerElectronics/DistributedGeneratorTest/DGTest.cpp
@@ -9,7 +9,7 @@
 
 #include <GridKit/Model/PowerElectronics/Bus/MicrogridBus.hpp>
 #include <GridKit/Model/PowerElectronics/Bus/SignalNode.hpp>
-#include <GridKit/Model/PowerElectronics/CircuitComponent.hpp>
+#include <GridKit/Model/PowerElectronics/Component.hpp>
 #include <GridKit/Model/PowerElectronics/DistributedGenerator/DistributedGenerator.hpp>
 
 /**
diff --git a/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp b/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp
index 9f9e2fa4a..8425cc87e 100644
--- a/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp
+++ b/examples/PowerElectronics/ExamplesHelper/MicrogridNetwork.hpp
@@ -13,7 +13,7 @@
 #include <GridKit/Model/PowerElectronics/MicrogridBusDQ/MicrogridBusDQ.hpp>
 #include <GridKit/Model/PowerElectronics/MicrogridLine/MicrogridLine.hpp>
 #include <GridKit/Model/PowerElectronics/MicrogridLoad/MicrogridLoad.hpp>
-#include <GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp>
+#include <GridKit/Model/PowerElectronics/SystemModel.hpp>
 
 /*
  * Contains components and nodes that make up the scaled microgrid network.
diff --git a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
index e77d82c6d..0fb939a52 100644
--- a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
+++ b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
@@ -29,11 +29,11 @@
  *       @p network have been added to @p sys_model.
  *
  * @note This function only assembles the network into the system model. It
- *       does not call PowerElectronicsModel::allocate().
+ *       does not call PowerElectronics::SystemModel::allocate().
  */
 template <class ScalarT, typename IdxT>
 void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>& network, 
-                    GridKit::PowerElectronics::PowerElectronicsModel<ScalarT, 
+                    GridKit::PowerElectronics::SystemModel<ScalarT, 
                     IdxT>& sys_model)
 {
   size_t N_size = network.N_size;
diff --git a/examples/PowerElectronics/Microgrid/Microgrid.cpp b/examples/PowerElectronics/Microgrid/Microgrid.cpp
index e365faded..0f568ccd4 100644
--- a/examples/PowerElectronics/Microgrid/Microgrid.cpp
+++ b/examples/PowerElectronics/Microgrid/Microgrid.cpp
@@ -2,7 +2,7 @@
 #include <cstddef>
 #include <iostream>
 
-#include <GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp>
+#include <GridKit/Model/PowerElectronics/SystemModel.hpp>
 #include <GridKit/Solver/Dynamic/DynamicSolver.hpp>
 #include <GridKit/Solver/Dynamic/Ida.hpp>
 
@@ -19,7 +19,7 @@ int main(int /* argc */, char const** /* argv */)
   bool   debug_output    = true;
 
   // Create model
-  auto* sysmodel = new GridKit::PowerElectronics::PowerElectronicsModel<double, size_t>(use_jac);
+  auto* sysmodel = new GridKit::PowerElectronics::SystemModel<double, size_t>(use_jac);
 
   // Build the four-generator microgrid network.
   size_t                                N_size = 2;
diff --git a/examples/PowerElectronics/RLCircuit/RLCircuit.cpp b/examples/PowerElectronics/RLCircuit/RLCircuit.cpp
index 07db313ee..4d3693442 100644
--- a/examples/PowerElectronics/RLCircuit/RLCircuit.cpp
+++ b/examples/PowerElectronics/RLCircuit/RLCircuit.cpp
@@ -7,7 +7,7 @@
 #include <GridKit/Model/PowerElectronics/Capacitor/Capacitor.hpp>
 #include <GridKit/Model/PowerElectronics/Inductor/Inductor.hpp>
 #include <GridKit/Model/PowerElectronics/Resistor/Resistor.hpp>
-#include <GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp>
+#include <GridKit/Model/PowerElectronics/SystemModel.hpp>
 #include <GridKit/Model/PowerElectronics/VoltageSource/VoltageSource.hpp>
 #include <GridKit/Solver/Dynamic/DynamicSolver.hpp>
 #include <GridKit/Solver/Dynamic/Ida.hpp>
@@ -20,7 +20,7 @@ int main(int /* argc */, char const** /* argv */)
 
   // TODO:setup as named parameters
   // Create circuit model
-  GridKit::PowerElectronics::PowerElectronicsModel<double, size_t> sysmodel(use_jac);
+  GridKit::PowerElectronics::SystemModel<double, size_t> sysmodel(use_jac);
 
   size_t idoff = 0;
 
diff --git a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp
index 9b3fc3836..134358745 100644
--- a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp
+++ b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogrid.cpp
@@ -2,7 +2,7 @@
 #include <iostream>
 #include <vector>
 
-#include <GridKit/Model/PowerElectronics/SystemModelPowerElectronics.hpp>
+#include <GridKit/Model/PowerElectronics/SystemModel.hpp>
 #include <GridKit/Solver/Dynamic/DynamicSolver.hpp>
 #include <GridKit/Solver/Dynamic/Ida.hpp>
 #include <GridKit/Testing/Testing.hpp>
@@ -67,7 +67,7 @@ int test(index_type Nsize, real_type error_tol, bool debug_output)
   real_type abs_tol = SCALE_MICROGRID_ABS_TOL;
 
   // Create circuit model
-  auto* sys_model = new PowerElectronicsModel<real_type, index_type>(use_jac);
+  auto* sys_model = new SystemModel<real_type, index_type>(use_jac);
 
   const std::vector<real_type>* true_vec = &answer_key_N8;
 
diff --git a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp
index 6ac49f16a..5e6e04803 100644
--- a/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp
+++ b/examples/PowerElectronics/ScaleMicrogrid/ScaleMicrogridArbitrary.cpp
@@ -65,7 +65,7 @@ int printMicrogridSystems(index_type N_size)
   real_type rel_tol = SCALE_MICROGRID_REL_TOL;
 
   // Create circuit model
-  PowerElectronicsModel<real_type, index_type> sys_model(use_jac);
+  SystemModel<real_type, index_type> sys_model(use_jac);
 
   // Ensure minimum size requirement
   if (N_size < 1)
diff --git a/tests/UnitTests/PowerElectronics/CMakeLists.txt b/tests/UnitTests/PowerElectronics/CMakeLists.txt
index 94cd4fd91..dc3c16737 100644
--- a/tests/UnitTests/PowerElectronics/CMakeLists.txt
+++ b/tests/UnitTests/PowerElectronics/CMakeLists.txt
@@ -1,4 +1,4 @@
-add_executable(test_power_electronics_node runCircuitNodeTests.cpp)
+add_executable(test_power_electronics_node runNodeTests.cpp)
 target_link_libraries(
   test_power_electronics_node
   PRIVATE GridKit::power_electronics_circuit_node GridKit::testing)
diff --git a/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp b/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp
index cf9492f34..d9f6d33da 100644
--- a/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp
+++ b/tests/UnitTests/PowerElectronics/ComponentCloneTests.hpp
@@ -13,7 +13,7 @@ namespace GridKit
   namespace Testing
   {
     template <typename ScalarT, typename IdxT>
-    class CircuitComponentCloneTests
+    class ComponentCloneTests
     {
       using SignalNode          = PowerElectronics::SignalNode<ScalarT, IdxT>;
       using Bus                 = PowerElectronics::MicrogridBus<ScalarT, IdxT>;
@@ -24,7 +24,7 @@ namespace GridKit
       using Load                = PowerElectronics::MicrogridLoad<ScalarT, IdxT>;
 
     public:
-      CircuitComponentCloneTests()
+      ComponentCloneTests()
       {
         /**************************************************************************
          * Construct Network Nodes
@@ -77,7 +77,7 @@ namespace GridKit
         bus_dq_->allocate();
       }
 
-      ~CircuitComponentCloneTests()
+      ~ComponentCloneTests()
       {
         delete generator_;
         delete line_;
@@ -125,7 +125,7 @@ namespace GridKit
       template <typename ComponentT>
       bool verifyComponentClone(ComponentT& component)
       {
-        using RealT = typename PowerElectronics::CircuitComponent<ScalarT, IdxT>::RealT;
+        using RealT = typename PowerElectronics::Component<ScalarT, IdxT>::RealT;
 
         bool success = true;
 
diff --git a/tests/UnitTests/PowerElectronics/CircuitNodeTests.hpp b/tests/UnitTests/PowerElectronics/NodeTests.hpp
similarity index 82%
rename from tests/UnitTests/PowerElectronics/CircuitNodeTests.hpp
rename to tests/UnitTests/PowerElectronics/NodeTests.hpp
index eb8574f3c..fa16ee018 100644
--- a/tests/UnitTests/PowerElectronics/CircuitNodeTests.hpp
+++ b/tests/UnitTests/PowerElectronics/NodeTests.hpp
@@ -2,7 +2,7 @@
 #include <iomanip>
 #include <iostream>
 
-#include <GridKit/Model/PowerElectronics/CircuitNode.hpp>
+#include <GridKit/Model/PowerElectronics/Node.hpp>
 #include <GridKit/Testing/TestHelpers.hpp>
 #include <GridKit/Testing/Testing.hpp>
 
@@ -24,10 +24,10 @@ namespace GridKit
 
         ScalarT V{1.0};
 
-        PowerElectronics::CircuitNode<ScalarT, IdxT>* node = nullptr;
+        PowerElectronics::Node<ScalarT, IdxT>* node = nullptr;
 
         // Default construct
-        node = new PowerElectronics::CircuitNode<ScalarT, IdxT>();
+        node = new PowerElectronics::Node<ScalarT, IdxT>();
         node->allocate();
         node->initialize();
         success *= isEqual(node->V(), static_cast<ScalarT>(0));
@@ -35,7 +35,7 @@ namespace GridKit
         delete node;
 
         // Construct with initial voltage
-        node = new PowerElectronics::CircuitNode<ScalarT, IdxT>(V);
+        node = new PowerElectronics::Node<ScalarT, IdxT>(V);
         node->allocate();
         node->initialize();
         success *= isEqual(node->V(), V);
@@ -56,7 +56,7 @@ namespace GridKit
         ScalarT V{1.0};
         ScalarT I{1.0};
 
-        PowerElectronics::CircuitNode<ScalarT, IdxT> node(V);
+        PowerElectronics::Node<ScalarT, IdxT> node(V);
         node.allocate();
         node.initialize();
         success *= isEqual(node.V(), V);
diff --git a/tests/UnitTests/PowerElectronics/runComponentCloneTests.cpp b/tests/UnitTests/PowerElectronics/runComponentCloneTests.cpp
index dfb5fa97f..83f052ec9 100644
--- a/tests/UnitTests/PowerElectronics/runComponentCloneTests.cpp
+++ b/tests/UnitTests/PowerElectronics/runComponentCloneTests.cpp
@@ -2,7 +2,7 @@
 
 int main()
 {
-  GridKit::Testing::CircuitComponentCloneTests<double, size_t> tests;
+  GridKit::Testing::ComponentCloneTests<double, size_t> tests;
 
   GridKit::Testing::TestingResults result;
 
diff --git a/tests/UnitTests/PowerElectronics/runCircuitNodeTests.cpp b/tests/UnitTests/PowerElectronics/runNodeTests.cpp
similarity index 86%
rename from tests/UnitTests/PowerElectronics/runCircuitNodeTests.cpp
rename to tests/UnitTests/PowerElectronics/runNodeTests.cpp
index 600babd50..25535b2fa 100644
--- a/tests/UnitTests/PowerElectronics/runCircuitNodeTests.cpp
+++ b/tests/UnitTests/PowerElectronics/runNodeTests.cpp
@@ -1,4 +1,4 @@
-#include "CircuitNodeTests.hpp"
+#include "NodeTests.hpp"
 
 int main()
 {

From ba6e2f271a7630f71f98b59de457737bcf2a2c4a Mon Sep 17 00:00:00 2001
From: nkoukpaizan <nkoukpaizan@users.noreply.github.com>
Date: Thu, 10 Sep 2026 20:21:17 +0000
Subject: [PATCH 4/6] Apply pre-commit fixes

---
 .../PowerElectronics/ExamplesHelper/SystemAssembler.hpp     | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
index 0fb939a52..b3c5ad0fc 100644
--- a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
+++ b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
@@ -32,9 +32,9 @@
  *       does not call PowerElectronics::SystemModel::allocate().
  */
 template <class ScalarT, typename IdxT>
-void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>& network, 
-                    GridKit::PowerElectronics::SystemModel<ScalarT, 
-                    IdxT>& sys_model)
+void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>&         network,
+                    GridKit::PowerElectronics::SystemModel<ScalarT,
+                                                           IdxT>& sys_model)
 {
   size_t N_size = network.N_size;
 

From fd96ee0a4a439d7e8ef33a4c92b0288d2d272331 Mon Sep 17 00:00:00 2001
From: Nicholson Koukpaizan <koukpaizannk@ornl.gov>
Date: Thu, 10 Sep 2026 16:23:56 -0400
Subject: [PATCH 5/6] Minor formatting.

---
 examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
index b3c5ad0fc..324cdb204 100644
--- a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
+++ b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
@@ -32,9 +32,8 @@
  *       does not call PowerElectronics::SystemModel::allocate().
  */
 template <class ScalarT, typename IdxT>
-void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>&         network,
-                    GridKit::PowerElectronics::SystemModel<ScalarT,
-                                                           IdxT>& sys_model)
+void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>&                  network,
+                    GridKit::PowerElectronics::SystemModel<ScalarT, IdxT>& sys_model)
 {
   size_t N_size = network.N_size;
 

From ce1dbd660a8b36cb25aa6da9db3bb7d89794f747 Mon Sep 17 00:00:00 2001
From: Nicholson Koukpaizan <72402802+nkoukpaizan@users.noreply.github.com>
Date: Fri, 11 Sep 2026 12:41:35 -0400
Subject: [PATCH 6/6] [skip ci] Apply suggestion from @abdourahmanbarry

Co-authored-by: abdourahmanbarry <153353767+abdourahmanbarry@users.noreply.github.com>
---
 examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
index 324cdb204..e46400a56 100644
--- a/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
+++ b/examples/PowerElectronics/ExamplesHelper/SystemAssembler.hpp
@@ -29,7 +29,7 @@
  *       @p network have been added to @p sys_model.
  *
  * @note This function only assembles the network into the system model. It
- *       does not call PowerElectronics::SystemModel::allocate().
+ *       does not call GridKit::PowerElectronics::SystemModel::allocate().
  */
 template <class ScalarT, typename IdxT>
 void assembleSystem(ScaleMicrogridNetwork<ScalarT, IdxT>&                  network,