Replace ComponentSignals with IOPorts implementation

GridKit/Model/PhasorDynamics/Branch/Branch.hpp

@@ -10,7 +10,6 @@
 
 #include <GridKit/Model/PhasorDynamics/Branch/BranchData.hpp>
 #include <GridKit/Model/PhasorDynamics/Component.hpp>
-#include <GridKit/Model/PhasorDynamics/ComponentSignals.hpp>
 #include <GridKit/Model/VariableMonitor.hpp>
 
 // Forward declarations.
@@ -20,9 +19,6 @@ namespace GridKit
   {
     template <typename scalar_type, typename index_type>
     class BusBase;
-
-    template <typename real_type, typename index_type>
-    struct BranchData;
   } // namespace PhasorDynamics
 } // namespace GridKit
 

GridKit/Model/PhasorDynamics/Branch/BranchData.hpp

@@ -67,21 +67,13 @@ namespace GridKit
      * Integer parameters are of the same type as matrix and vector indices.
      */
     template <typename real_type, typename index_type>
-    struct BranchData : public ComponentData<real_type,
-                                             index_type,
-                                             BranchParameters,
-                                             BranchBuses,
-                                             BranchSignalInputs,
-                                             BranchSignalOutputs,
-                                             BranchMonitorableVariables>
-    {
-      BranchData() = default;
-
-      using Parameters           = BranchParameters;
-      using Buses                = BranchBuses;
-      using SignalInputs         = BranchSignalInputs;
-      using SignalOutputs        = BranchSignalOutputs;
-      using MonitorableVariables = BranchMonitorableVariables;
-    };
+    using BranchData =
+        ComponentData<real_type,
+                      index_type,
+                      BranchParameters,
+                      BranchBuses,
+                      BranchSignalInputs,
+                      BranchSignalOutputs,
+                      BranchMonitorableVariables>;
   } // namespace PhasorDynamics
 } // namespace GridKit

GridKit/Model/PhasorDynamics/BusFault/BusFault.hpp

@@ -2,20 +2,10 @@
 #pragma once
 
 #include <GridKit/Model/PhasorDynamics/BusBase.hpp>
+#include <GridKit/Model/PhasorDynamics/BusFault/BusFaultData.hpp>
 #include <GridKit/Model/PhasorDynamics/Component.hpp>
-#include <GridKit/Model/PhasorDynamics/ComponentSignals.hpp>
 #include <GridKit/Model/VariableMonitor.hpp>
 
-// Forward declaration of BusData structure
-namespace GridKit
-{
-  namespace PhasorDynamics
-  {
-    template <typename real_type, typename index_type>
-    struct BusFaultData;
-  }
-} // namespace GridKit
-
 namespace GridKit
 {
   namespace PhasorDynamics

GridKit/Model/PhasorDynamics/BusFault/BusFaultData.hpp

@@ -57,21 +57,13 @@ namespace GridKit
      * Integer parameters are of the same type as matrix and vector indices.
      */
     template <typename real_type, typename index_type>
-    struct BusFaultData : public ComponentData<real_type,
-                                               index_type,
-                                               BusFaultParameters,
-                                               BusFaultBuses,
-                                               BusFaultSignalInputs,
-                                               BusFaultSignalOutputs,
-                                               BusFaultMonitorableVariables>
-    {
-      BusFaultData() = default;
-
-      using Parameters           = BusFaultParameters;
-      using Buses                = BusFaultBuses;
-      using SignalInputs         = BusFaultSignalInputs;
-      using SignalOutputs        = BusFaultSignalOutputs;
-      using MonitorableVariables = BusFaultMonitorableVariables;
-    };
+    using BusFaultData =
+        ComponentData<real_type,
+                      index_type,
+                      BusFaultParameters,
+                      BusFaultBuses,
+                      BusFaultSignalInputs,
+                      BusFaultSignalOutputs,
+                      BusFaultMonitorableVariables>;
   } // namespace PhasorDynamics
 } // namespace GridKit

GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapter.hpp

@@ -8,48 +8,39 @@
 #pragma once
 
 #include <GridKit/Constants.hpp>
+#include <GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapterData.hpp>
 #include <GridKit/Model/PhasorDynamics/Component.hpp>
-#include <GridKit/Model/PhasorDynamics/ComponentSignals.hpp>
+#include <GridKit/Model/PhasorDynamics/IOPorts.hpp>
 
 // Forward declarations
 namespace GridKit
 {
   namespace PhasorDynamics
   {
-    template <typename real_type, typename index_type>
-    struct BusToSignalAdapterData;
-
     template <typename scalar_type, typename index_type>
     class BusBase;
 
     template <typename scalar_type, typename index_type>
     class SignalNode;
+
+    template <typename signal_node_type>
+    class SignalNodeSet;
   } // namespace PhasorDynamics
 } // namespace GridKit
 
 namespace GridKit
 {
   namespace PhasorDynamics
   {
-    /**
-     * @brief Internal variables of a `BusToSignalAdapter`
-     *
-     * @note Technically these are not owned by this component, but they must
-     * be classified as internal so that they can be written to signal nodes
-     * in `ComponentSignals`
-     */
+    /// Internal variables of a `BusToSignalAdapter`
     enum class BusToSignalAdapterInternalVariables : size_t
     {
-      VREAL,
-      VIMAG,
       MAXIMUM,
     };
 
     /// External variables of a `BusToSignalAdapter`
     enum class BusToSignalAdapterExternalVariables : size_t
     {
-      IREAL,
-      IIMAG,
       MAXIMUM,
     };
 
@@ -60,14 +51,19 @@ namespace GridKit
       using Component<scalar_type, index_type>::size_;
 
     public:
-      using ScalarT    = scalar_type;
-      using IdxT       = index_type;
-      using RealT      = typename Component<ScalarT, IdxT>::RealT;
-      using ModelDataT = BusToSignalAdapterData<RealT, IdxT>;
-      using SignalT    = SignalNode<ScalarT, IdxT>;
-      using BusT       = BusBase<ScalarT, IdxT>;
+      using ScalarT        = scalar_type;
+      using IdxT           = index_type;
+      using RealT          = typename Component<ScalarT, IdxT>::RealT;
+      using ModelDataT     = BusToSignalAdapterData<RealT, IdxT>;
+      using BusT           = BusBase<ScalarT, IdxT>;
+      using SignalNodeT    = SignalNode<ScalarT, IdxT>;
+      using SignalNodeSetT = SignalNodeSet<SignalNodeT>;
+      using IOPortsT       = IOPorts<ScalarT, ModelDataT>;
 
       BusToSignalAdapter(BusT* bus);
+      BusToSignalAdapter(BusT*             bus,
+                         const ModelDataT& data,
+                         SignalNodeSetT&   signal_nodes);
       ~BusToSignalAdapter();
 
       int setGridKitComponentID(IdxT) override final;
@@ -79,28 +75,21 @@ namespace GridKit
       int evaluateResidual() override final;
       int evaluateJacobian() override final;
 
-      /// Get the `ComponentSignals` from this `BusToSignalAdapter`
-      auto getSignals()
-          -> ComponentSignals<ScalarT,
-                              IdxT,
-                              BusToSignalAdapterInternalVariables,
-                              BusToSignalAdapterExternalVariables>&
+      IOPortsT& getPorts()
       {
-        return signals_;
+        return ports_;
       }
 
     private:
       // Placeholders for variable indices (see note in allocate() method)
       IdxT vr_index_{INVALID_INDEX<IdxT>};
       IdxT vi_index_{INVALID_INDEX<IdxT>};
 
-      // Signal pointers
-      SignalT* ir_signal_;
-      SignalT* ii_signal_;
-      BusT*    bus_;
+      // Bus pointer
+      BusT* bus_;
 
-      /// Component signal extension
-      ComponentSignals<ScalarT, IdxT, BusToSignalAdapterInternalVariables, BusToSignalAdapterExternalVariables> signals_;
+      // Component ports
+      IOPortsT ports_;
     };
 
   } // namespace PhasorDynamics

GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapterData.hpp

@@ -67,23 +67,14 @@ namespace GridKit
      * @tparam IdxT  Index type (e.g., size_t)
      */
     template <typename real_type, typename index_type>
-    struct BusToSignalAdapterData
-      : public ComponentData<real_type,
-                             index_type,
-                             BusToSignalAdapterParameters,
-                             BusToSignalAdapterBuses,
-                             BusToSignalAdapterSignalInputs,
-                             BusToSignalAdapterSignalOutputs,
-                             BusToSignalAdapterMonitorableVariables>
-    {
-      BusToSignalAdapterData() = default;
-
-      using Parameters           = BusToSignalAdapterParameters;
-      using Buses                = BusToSignalAdapterBuses;
-      using SignalInputs         = BusToSignalAdapterSignalInputs;
-      using SignalOutputs        = BusToSignalAdapterSignalOutputs;
-      using MonitorableVariables = BusToSignalAdapterMonitorableVariables;
-    };
+    using BusToSignalAdapterData =
+        ComponentData<real_type,
+                      index_type,
+                      BusToSignalAdapterParameters,
+                      BusToSignalAdapterBuses,
+                      BusToSignalAdapterSignalInputs,
+                      BusToSignalAdapterSignalOutputs,
+                      BusToSignalAdapterMonitorableVariables>;
 
   } // namespace PhasorDynamics
 } // namespace GridKit

GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapterImpl.hpp

@@ -9,7 +9,9 @@
 #include <GridKit/Model/PhasorDynamics/Bus/Bus.hpp>
 #include <GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapter.hpp>
 #include <GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapterData.hpp>
+#include <GridKit/Model/PhasorDynamics/ComponentData.hpp>
 #include <GridKit/Model/PhasorDynamics/SignalNode/SignalNode.hpp>
+#include <GridKit/Model/PhasorDynamics/SignalNode/SignalNodeSet.hpp>
 #include <GridKit/Utilities/Logger/Logger.hpp>
 
 namespace GridKit
@@ -31,6 +33,25 @@ namespace GridKit
       size_ = 0;
     }
 
+    /**
+     * @brief  Constructor for BusToSignalAdapter component
+     *
+     * @param bus          Signal used for voltage
+     * @param data         Data object
+     * @param signal_nodes SignalNodeSet instance for accessing system signal
+     * nodes
+     */
+    template <typename scalar_type, typename index_type>
+    BusToSignalAdapter<scalar_type, index_type>::BusToSignalAdapter(
+        BusT*             bus,
+        const ModelDataT& data,
+        SignalNodeSetT&   signal_nodes)
+      : bus_(bus),
+        ports_(data, signal_nodes)
+    {
+      size_ = 0;
+    }
+
     template <typename scalar_type, typename index_type>
     BusToSignalAdapter<scalar_type, index_type>::~BusToSignalAdapter()
     {
@@ -52,19 +73,18 @@ namespace GridKit
     template <typename scalar_type, typename index_type>
     int BusToSignalAdapter<scalar_type, index_type>::allocate()
     {
-      static constexpr auto VREAL = BusToSignalAdapterInternalVariables::VREAL;
-      static constexpr auto VIMAG = BusToSignalAdapterInternalVariables::VIMAG;
+      using SignalOut = BusToSignalAdapterSignalOutputs;
 
       // vr_index_ and vi_index_ are both set to INVALID_INDEX. This component
       // simply passes voltage from bus to output signal, so indices are
       // ignored.
-      if (signals_.template isAssigned<VREAL>())
+      if (auto vr_port = ports_.out[SignalOut::vr])
       {
-        signals_.template getSignalNode<VREAL>()->set(&bus_->Vr(), &vr_index_);
+        vr_port.link(&bus_->Vr(), &vr_index_);
       }
-      if (signals_.template isAssigned<VIMAG>())
+      if (auto vi_port = ports_.out[SignalOut::vi])
       {
-        signals_.template getSignalNode<VIMAG>()->set(&bus_->Vi(), &vi_index_);
+        vi_port.link(&bus_->Vi(), &vi_index_);
       }
 
       return 0;
@@ -76,27 +96,22 @@ namespace GridKit
     template <typename scalar_type, typename index_type>
     int BusToSignalAdapter<scalar_type, index_type>::verify() const
     {
-      static constexpr auto IREAL = BusToSignalAdapterExternalVariables::IREAL;
-      static constexpr auto IIMAG = BusToSignalAdapterExternalVariables::IIMAG;
+      using SignalIn = BusToSignalAdapterSignalInputs;
 
       int ret = 0;
 
-      if (signals_.template isAttached<IREAL>())
+      auto ir_port = ports_.in[SignalIn::ir];
+      if (ir_port.connected() && !ir_port.linked())
       {
-        if (!signals_.template isLinked<IREAL>())
-        {
-          Log::error() << "BusToSignalAdapter: Ir signal attached with no linked source\n";
-          ret += 1;
-        }
+        Log::error() << "BusToSignalAdapter: Ir signal attached with no linked source\n";
+        ret += 1;
       }
 
-      if (signals_.template isAttached<IIMAG>())
+      auto ii_port = ports_.in[SignalIn::ir];
+      if (ii_port.connected() && !ii_port.linked())
       {
-        if (!signals_.template isLinked<IIMAG>())
-        {
-          Log::error() << "BusToSignalAdapter: Ii signal attached with no linked source\n";
-          ret += 1;
-        }
+        Log::error() << "BusToSignalAdapter: Ii signal attached with no linked source\n";
+        ret += 1;
       }
 
       return ret;
@@ -144,16 +159,15 @@ namespace GridKit
     template <typename scalar_type, typename index_type>
     int BusToSignalAdapter<scalar_type, index_type>::evaluateResidual()
     {
-      static constexpr auto IREAL = BusToSignalAdapterExternalVariables::IREAL;
-      static constexpr auto IIMAG = BusToSignalAdapterExternalVariables::IIMAG;
+      using SignalIn = BusToSignalAdapterSignalInputs;
 
-      if (signals_.template isAttached<IREAL>())
+      if (auto ir_port = ports_.in[SignalIn::ir])
       {
-        bus_->Ir() += signals_.template readExternalVariable<IREAL>();
+        bus_->Ir() += ir_port.readSignal();
       }
-      if (signals_.template isAttached<IIMAG>())
+      if (auto ii_port = ports_.in[SignalIn::ii])
       {
-        bus_->Ii() += signals_.template readExternalVariable<IIMAG>();
+        bus_->Ii() += ii_port.readSignal();
       }
 
       return 0;

GridKit/Model/PhasorDynamics/CMakeLists.txt

@@ -13,7 +13,7 @@ gridkit_add_library(
           Component.hpp
           ComponentData.hpp
           ComponentLibrary.hpp
-          ComponentSignals.hpp
+          IOPorts.hpp
   LINK_LIBRARIES
     INTERFACE
     GridKit::definitions