Use ports for PhasorDynamics signal connectivity

GridKit/Model/PhasorDynamics/Branch/BranchData.hpp

@@ -23,11 +23,24 @@ namespace GridKit
       phase, ///< Phase shift angle in radians
     };
 
-    /// Ports for a branch
-    enum class BranchPorts
+    /// Terminals for a branch
+    enum class BranchTerminals : size_t
     {
       bus1, ///< Unique ID of bus 1
       bus2, ///< Unique ID of bus 2
+      SIZE
+    };
+
+    /// Input ports supported for a branch
+    enum class BranchInputPorts : size_t
+    {
+      SIZE
+    };
+
+    /// Output ports supported for a branch
+    enum class BranchOutputPorts : size_t
+    {
+      SIZE
     };
 
     /// Variables able to be monitored for a branch
@@ -57,13 +70,17 @@ namespace GridKit
     struct BranchData : public ComponentData<real_type,
                                              index_type,
                                              BranchParameters,
-                                             BranchPorts,
+                                             BranchTerminals,
+                                             BranchInputPorts,
+                                             BranchOutputPorts,
                                              BranchMonitorableVariables>
     {
       BranchData() = default;
 
       using Parameters           = BranchParameters;
-      using Ports                = BranchPorts;
+      using Terminals            = BranchTerminals;
+      using InputPorts           = BranchInputPorts;
+      using OutputPorts          = BranchOutputPorts;
       using MonitorableVariables = BranchMonitorableVariables;
     };
   } // namespace PhasorDynamics

GridKit/Model/PhasorDynamics/Branch/BranchImpl.hpp

@@ -310,21 +310,24 @@ namespace GridKit
     template <typename scalar_type, typename index_type>
     void Branch<scalar_type, index_type>::initializeParameters(const ModelDataT& data)
     {
-      readRealParameter(data, ModelDataT::Parameters::R, R_);
-      readRealParameter(data, ModelDataT::Parameters::X, X_);
-      readRealParameter(data, ModelDataT::Parameters::G, G_);
-      readRealParameter(data, ModelDataT::Parameters::B, B_);
-      readRealParameter(data, ModelDataT::Parameters::tap, tap_);
-      readRealParameter(data, ModelDataT::Parameters::phase, phase_);
-
-      if (data.ports.contains(ModelDataT::Ports::bus1))
+      using Parameter = typename ModelDataT::Parameters;
+      using Terminal  = typename ModelDataT::Terminals;
+
+      readRealParameter(data, Parameter::R, R_);
+      readRealParameter(data, Parameter::X, X_);
+      readRealParameter(data, Parameter::G, G_);
+      readRealParameter(data, Parameter::B, B_);
+      readRealParameter(data, Parameter::tap, tap_);
+      readRealParameter(data, Parameter::phase, phase_);
+
+      if (data.terminals.contains(Terminal::bus1))
       {
-        bus1_id_ = data.ports.at(ModelDataT::Ports::bus1);
+        bus1_id_ = data.terminals.at(Terminal::bus1);
       }
 
-      if (data.ports.contains(ModelDataT::Ports::bus2))
+      if (data.terminals.contains(Terminal::bus2))
       {
-        bus2_id_ = data.ports.at(ModelDataT::Ports::bus2);
+        bus2_id_ = data.terminals.at(Terminal::bus2);
       }
     }
 

GridKit/Model/PhasorDynamics/BusFault/BusFaultData.hpp

@@ -20,11 +20,24 @@ namespace GridKit
       X,      ///< Short to ground reactance
     };
 
-    /// Ports supported for a bus fault
-    enum class BusFaultPorts
+    /// Terminals supported for a bus fault
+    enum class BusFaultTerminals : size_t
+    {
+      bus, ///< Unique ID of the bus where the fault occurs
+      SIZE
+    };
+
+    /// Input ports supported for a bus fault
+    enum class BusFaultInputPorts : size_t
     {
-      bus,            ///< Unique ID of the bus where the fault occurs
       control_signal, ///< Unique ID of the bus providing a control signal
+      SIZE
+    };
+
+    /// Output ports supported for a bus fault
+    enum class BusFaultOutputPorts : size_t
+    {
+      SIZE
     };
 
     /// Variables able to be monitored for a bus fault
@@ -47,13 +60,17 @@ namespace GridKit
     struct BusFaultData : public ComponentData<real_type,
                                                index_type,
                                                BusFaultParameters,
-                                               BusFaultPorts,
+                                               BusFaultTerminals,
+                                               BusFaultInputPorts,
+                                               BusFaultOutputPorts,
                                                BusFaultMonitorableVariables>
     {
       BusFaultData() = default;
 
       using Parameters           = BusFaultParameters;
-      using Ports                = BusFaultPorts;
+      using Terminals            = BusFaultTerminals;
+      using InputPorts           = BusFaultInputPorts;
+      using OutputPorts          = BusFaultOutputPorts;
       using MonitorableVariables = BusFaultMonitorableVariables;
     };
   } // namespace PhasorDynamics

GridKit/Model/PhasorDynamics/BusFault/BusFaultImpl.hpp

@@ -57,24 +57,27 @@ namespace GridKit
       : bus_(bus),
         monitor_(std::make_unique<MonitorT>(data))
     {
-      if (data.parameters.contains(ModelDataT::Parameters::R))
+      using Parameter = typename ModelDataT::Parameters;
+      using Terminal  = typename ModelDataT::Terminals;
+
+      if (data.parameters.contains(Parameter::R))
       {
-        R_ = std::get<RealT>(data.parameters.at(ModelDataT::Parameters::R));
+        R_ = std::get<RealT>(data.parameters.at(Parameter::R));
       }
 
-      if (data.parameters.contains(ModelDataT::Parameters::X))
+      if (data.parameters.contains(Parameter::X))
       {
-        X_ = std::get<RealT>(data.parameters.at(ModelDataT::Parameters::X));
+        X_ = std::get<RealT>(data.parameters.at(Parameter::X));
       }
 
-      if (data.parameters.contains(ModelDataT::Parameters::state0))
+      if (data.parameters.contains(Parameter::state0))
       {
-        status_ = std::get<bool>(data.parameters.at(ModelDataT::Parameters::state0));
+        status_ = std::get<bool>(data.parameters.at(Parameter::state0));
       }
 
-      if (data.ports.contains(ModelDataT::Ports::bus))
+      if (data.terminals.contains(Terminal::bus))
       {
-        bus_id_ = data.ports.at(ModelDataT::Ports::bus);
+        bus_id_ = data.terminals.at(Terminal::bus);
       }
 
       using Variable = typename ModelDataT::MonitorableVariables;

GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapter.hpp

@@ -8,6 +8,7 @@
 #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>
 
@@ -16,9 +17,6 @@ namespace GridKit
 {
   namespace PhasorDynamics
   {
-    template <typename real_type, typename index_type>
-    struct BusToSignalAdapterData;
-
     template <typename scalar_type, typename index_type>
     class BusBase;
 
@@ -35,8 +33,8 @@ namespace GridKit
      * @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`
+     * remain model variables so the adapter can bind its output ports to bus
+     * voltage storage.
      */
     enum class BusToSignalAdapterInternalVariables : size_t
     {
@@ -82,8 +80,8 @@ namespace GridKit
       auto getSignals()
           -> ComponentSignals<ScalarT,
                               IdxT,
-                              BusToSignalAdapterInternalVariables,
-                              BusToSignalAdapterExternalVariables>&
+                              BusToSignalAdapterInputPorts,
+                              BusToSignalAdapterOutputPorts>&
       {
         return signals_;
       }
@@ -99,7 +97,7 @@ namespace GridKit
       BusT*    bus_;
 
       /// Component signal extension
-      ComponentSignals<ScalarT, IdxT, BusToSignalAdapterInternalVariables, BusToSignalAdapterExternalVariables> signals_;
+      ComponentSignals<ScalarT, IdxT, BusToSignalAdapterInputPorts, BusToSignalAdapterOutputPorts> signals_;
     };
 
   } // namespace PhasorDynamics

GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapterData.hpp

@@ -24,15 +24,32 @@ namespace GridKit
     };
 
     /**
-     * @brief BusToSignalAdapter ports
+     * @brief BusToSignalAdapter terminals
      */
-    enum class BusToSignalAdapterPorts
+    enum class BusToSignalAdapterTerminals : size_t
     {
       bus,
-      vr,
-      vi,
+      SIZE
+    };
+
+    /**
+     * @brief BusToSignalAdapter input ports
+     */
+    enum class BusToSignalAdapterInputPorts : size_t
+    {
       ir,
       ii,
+      SIZE
+    };
+
+    /**
+     * @brief BusToSignalAdapter output ports
+     */
+    enum class BusToSignalAdapterOutputPorts : size_t
+    {
+      vr,
+      vi,
+      SIZE
     };
 
     /**
@@ -54,13 +71,17 @@ namespace GridKit
       : public ComponentData<real_type,
                              index_type,
                              BusToSignalAdapterParameters,
-                             BusToSignalAdapterPorts,
+                             BusToSignalAdapterTerminals,
+                             BusToSignalAdapterInputPorts,
+                             BusToSignalAdapterOutputPorts,
                              BusToSignalAdapterMonitorableVariables>
     {
       BusToSignalAdapterData() = default;
 
       using Parameters           = BusToSignalAdapterParameters;
-      using Ports                = BusToSignalAdapterPorts;
+      using Terminals            = BusToSignalAdapterTerminals;
+      using InputPorts           = BusToSignalAdapterInputPorts;
+      using OutputPorts          = BusToSignalAdapterOutputPorts;
       using MonitorableVariables = BusToSignalAdapterMonitorableVariables;
     };
 

GridKit/Model/PhasorDynamics/BusToSignalAdapter/BusToSignalAdapterImpl.hpp

@@ -52,19 +52,19 @@ 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;
+      static constexpr auto VR = BusToSignalAdapterOutputPorts::vr;
+      static constexpr auto VI = BusToSignalAdapterOutputPorts::vi;
 
       // 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 (signals_.template isAssigned<VR>())
       {
-        signals_.template getSignalNode<VREAL>()->set(&bus_->Vr(), &vr_index_);
+        signals_.template getSignalNode<VR>()->set(&bus_->Vr(), &vr_index_);
       }
-      if (signals_.template isAssigned<VIMAG>())
+      if (signals_.template isAssigned<VI>())
       {
-        signals_.template getSignalNode<VIMAG>()->set(&bus_->Vi(), &vi_index_);
+        signals_.template getSignalNode<VI>()->set(&bus_->Vi(), &vi_index_);
       }
 
       return 0;
@@ -76,23 +76,23 @@ 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;
+      static constexpr auto IR = BusToSignalAdapterInputPorts::ir;
+      static constexpr auto II = BusToSignalAdapterInputPorts::ii;
 
       int ret = 0;
 
-      if (signals_.template isAttached<IREAL>())
+      if (signals_.template isAttached<IR>())
       {
-        if (!signals_.template isLinked<IREAL>())
+        if (!signals_.template isLinked<IR>())
         {
           Log::error() << "BusToSignalAdapter: Ir signal attached with no linked source\n";
           ret += 1;
         }
       }
 
-      if (signals_.template isAttached<IIMAG>())
+      if (signals_.template isAttached<II>())
       {
-        if (!signals_.template isLinked<IIMAG>())
+        if (!signals_.template isLinked<II>())
         {
           Log::error() << "BusToSignalAdapter: Ii signal attached with no linked source\n";
           ret += 1;
@@ -126,16 +126,16 @@ 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;
+      static constexpr auto IR = BusToSignalAdapterInputPorts::ir;
+      static constexpr auto II = BusToSignalAdapterInputPorts::ii;
 
-      if (signals_.template isAttached<IREAL>())
+      if (signals_.template isAttached<IR>())
       {
-        bus_->Ir() += signals_.template readExternalVariable<IREAL>();
+        bus_->Ir() += signals_.template readExternalVariable<IR>();
       }
-      if (signals_.template isAttached<IIMAG>())
+      if (signals_.template isAttached<II>())
       {
-        bus_->Ii() += signals_.template readExternalVariable<IIMAG>();
+        bus_->Ii() += signals_.template readExternalVariable<II>();
       }
 
       return 0;

GridKit/Model/PhasorDynamics/ComponentData.hpp

@@ -20,10 +20,14 @@ namespace GridKit
     template <typename real_type,
               typename index_type,
               typename Parameters,
-              typename Ports,
+              typename Terminals,
+              typename InputPorts,
+              typename OutputPorts,
               typename MonitorableVariables>
       requires std::is_enum_v<Parameters>
-               && std::is_enum_v<Ports>
+               && std::is_enum_v<Terminals>
+               && std::is_enum_v<InputPorts>
+               && std::is_enum_v<OutputPorts>
                && std::is_enum_v<MonitorableVariables>
     struct ComponentData
     {
@@ -38,8 +42,14 @@ namespace GridKit
       /// Mapping of parameters to parameter values
       std::map<Parameters, std::variant<bool, RealT, IdxT>> parameters;
 
-      /// Mapping of ports to port values
-      std::map<Ports, IdxT> ports;
+      /// Mapping of terminal attachments to bus identifiers
+      std::map<Terminals, IdxT> terminals;
+
+      /// Mapping of signal input ports to signal identifiers
+      std::map<InputPorts, IdxT> input_ports;
+
+      /// Mapping of signal output ports to signal identifiers
+      std::map<OutputPorts, IdxT> output_ports;
 
       /// Set of variables being monitored
       std::set<MonitorableVariables> monitored_variables;