ConstantSignalSource component and example with BusToSignalAdapter

CHANGELOG.md

@@ -64,6 +64,7 @@
 - Added off-nominal tap ratio and phase shift support to the PhasorDynamics `Branch` model.
 - Added portable Vector class to GridKit
 - Added support for running IDA with fixed time steps
+- Added `ConstantSignalSource` component as first use case for `BusToSignalAdapter`.
 - Added IDA option to suppress algebraic variables in local error tests.
 - Removed `COO_Matrix` class.
 

GridKit/Model/PhasorDynamics/CMakeLists.txt

@@ -37,6 +37,7 @@ add_subdirectory(Exciter)
 add_subdirectory(Governor)
 add_subdirectory(Load)
 add_subdirectory(SignalNode)
+add_subdirectory(SignalSource)
 add_subdirectory(Stabilizer)
 add_subdirectory(SynchronousMachine)
 

GridKit/Model/PhasorDynamics/ComponentLibrary.hpp

@@ -11,6 +11,7 @@
 #include <GridKit/Model/PhasorDynamics/Load/LoadZ/LoadZ.hpp>
 #include <GridKit/Model/PhasorDynamics/Load/LoadZIP/LoadZIP.hpp>
 #include <GridKit/Model/PhasorDynamics/SignalNode/SignalNode.hpp>
+#include <GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSource.hpp>
 #include <GridKit/Model/PhasorDynamics/Stabilizer/IEEEST/Ieeest.hpp>
 #include <GridKit/Model/PhasorDynamics/SynchronousMachine/GENROUwS/Genrou.hpp>
 #include <GridKit/Model/PhasorDynamics/SynchronousMachine/GENSALwS/Gensal.hpp>

GridKit/Model/PhasorDynamics/SignalSource/CMakeLists.txt

@@ -0,0 +1,20 @@
+set(_install_headers ConstantSignalSource.hpp ConstantSignalSourceData.hpp)
+
+gridkit_add_library(
+  phasor_dynamics_signalsource
+  SOURCES ConstantSignalSource.cpp
+  HEADERS ${_install_headers}
+  LINK_LIBRARIES GridKit::phasor_dynamics_core GridKit::phasor_dynamics_signal)
+
+gridkit_add_library(
+  phasor_dynamics_signalsource_dependency_tracking
+  SOURCES ConstantSignalSourceDependencyTracking.cpp
+  LINK_LIBRARIES GridKit::phasor_dynamics_core GridKit::phasor_dynamics_signal_dependency_tracking)
+
+# Link to interface target for all components
+target_link_libraries(
+  phasor_dynamics_components
+  INTERFACE GridKit::phasor_dynamics_signalsource)
+target_link_libraries(
+  phasor_dynamics_components_dependency_tracking
+  INTERFACE GridKit::phasor_dynamics_signalsource_dependency_tracking)

GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSource.cpp

@@ -0,0 +1,13 @@
+
+#include "ConstantSignalSourceImpl.hpp"
+
+namespace GridKit
+{
+  namespace PhasorDynamics
+  {
+    // Available template instantiations
+    template class ConstantSignalSource<double, long int>;
+    template class ConstantSignalSource<double, size_t>;
+
+  } // namespace PhasorDynamics
+} // namespace GridKit

GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSource.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <GridKit/Model/PhasorDynamics/Component.hpp>
+#include <GridKit/Model/PhasorDynamics/ComponentSignals.hpp>
+
+namespace GridKit
+{
+  namespace PhasorDynamics
+  {
+    // Forward declaration
+    template <typename real_type, typename index_type>
+    struct ConstantSignalSourceData;
+
+    /// Internal variables for ConstantSignalSource
+    enum class ConstantSignalSourceInternalVariables : size_t
+    {
+      SREAL,
+      SIMAG,
+      MAXIMUM,
+    };
+
+    /// No external variables for ConstantSignalSource
+    enum class ConstantSignalSourceExternalVariables : size_t
+    {
+      MAXIMUM,
+    };
+
+    /**
+     * @brief Constant signal source component
+     *
+     * This class emits a constant complex value on two output signals (real and
+     * imaginary).
+     */
+    template <typename scalar_type, typename index_type>
+    class ConstantSignalSource : public Component<scalar_type, index_type>
+    {
+      using Component<scalar_type, index_type>::gridkit_component_id_;
+      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 = ConstantSignalSourceData<RealT, IdxT>;
+
+      ConstantSignalSource();
+      ConstantSignalSource(const ModelDataT& data);
+      ~ConstantSignalSource();
+
+      int setGridKitComponentID(IdxT) override final;
+      int allocate() override final;
+      int verify() const override final;
+      int initialize() override final;
+      int tagDifferentiable() override final;
+      int setAbsoluteTolerance(RealT) override final;
+      int evaluateResidual() override final;
+      int evaluateJacobian() override final;
+
+      /// Get the `ComponentSignals` from this component
+      auto getSignals()
+          -> ComponentSignals<ScalarT,
+                              IdxT,
+                              ConstantSignalSourceInternalVariables,
+                              ConstantSignalSourceExternalVariables>&
+      {
+        return signals_;
+      }
+
+    private:
+      /// Real part of source value
+      ScalarT s_real_{0.0};
+      /// Imaginary part of source value
+      ScalarT s_imag_{0.0};
+
+      // Placeholders for variable indices
+      IdxT sr_index_{INVALID_INDEX<IdxT>};
+      IdxT si_index_{INVALID_INDEX<IdxT>};
+
+      /// Component signals
+      ComponentSignals<ScalarT, IdxT, ConstantSignalSourceInternalVariables, ConstantSignalSourceExternalVariables> signals_;
+
+      // Parameter initialization function
+      void initializeParameters(const ModelDataT& data);
+    };
+  } // namespace PhasorDynamics
+} // namespace GridKit

GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSourceData.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <GridKit/Model/PhasorDynamics/ComponentData.hpp>
+
+namespace GridKit
+{
+  namespace PhasorDynamics
+  {
+    enum class ConstantSignalSourceParameters
+    {
+      Sr,
+      Si
+    };
+
+    enum class ConstantSignalSourcePorts
+    {
+      sr,
+      si
+    };
+
+    enum class ConstantSignalSourceMonitorableVariables
+    {
+      NONE,
+    };
+
+    template <typename real_type, typename index_type>
+    struct ConstantSignalSourceData : public ComponentData<real_type,
+                                                           index_type,
+                                                           ConstantSignalSourceParameters,
+                                                           ConstantSignalSourcePorts,
+                                                           ConstantSignalSourceMonitorableVariables>
+    {
+      ConstantSignalSourceData() = default;
+
+      using Parameters           = ConstantSignalSourceParameters;
+      using Ports                = ConstantSignalSourcePorts;
+      using MonitorableVariables = ConstantSignalSourceMonitorableVariables;
+    };
+
+  } // namespace PhasorDynamics
+} // namespace GridKit

GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSourceDependencyTracking.cpp

@@ -0,0 +1,13 @@
+
+#include "ConstantSignalSourceImpl.hpp"
+
+namespace GridKit
+{
+  namespace PhasorDynamics
+  {
+    // Available template instantiations
+    template class ConstantSignalSource<DependencyTracking::Variable, long int>;
+    template class ConstantSignalSource<DependencyTracking::Variable, size_t>;
+
+  } // namespace PhasorDynamics
+} // namespace GridKit

GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSourceImpl.hpp

@@ -0,0 +1,121 @@
+
+#include <GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSource.hpp>
+#include <GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSourceData.hpp>
+#include <GridKit/Utilities/Logger/Logger.hpp>
+
+namespace GridKit
+{
+  namespace PhasorDynamics
+  {
+    using Log = ::GridKit::Utilities::Logger;
+
+    /**
+     * @brief Default construct with zero value
+     */
+    template <typename scalar_type, typename index_type>
+    ConstantSignalSource<scalar_type, index_type>::ConstantSignalSource()
+    {
+      size_ = 0;
+    }
+
+    /**
+     * @brief Construct with values from input data
+     */
+    template <typename scalar_type, typename index_type>
+    ConstantSignalSource<scalar_type, index_type>::ConstantSignalSource(const ModelDataT& data)
+    {
+      initializeParameters(data);
+      size_ = 0;
+    }
+
+    template <typename scalar_type, typename index_type>
+    ConstantSignalSource<scalar_type, index_type>::~ConstantSignalSource()
+    {
+    }
+
+    /**
+     * @brief Set value from input data
+     */
+    template <typename scalar_type, typename index_type>
+    void ConstantSignalSource<scalar_type, index_type>::initializeParameters(const ModelDataT& data)
+    {
+      using Parameters = ModelDataT::Parameters;
+      if (data.parameters.contains(Parameters::Sr))
+      {
+        s_real_ = std::get<RealT>(data.parameters.at(Parameters::Sr));
+      }
+      if (data.parameters.contains(Parameters::Si))
+      {
+        s_imag_ = std::get<RealT>(data.parameters.at(Parameters::Si));
+      }
+    }
+
+    /**
+     * @brief Set the component ID
+     */
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::setGridKitComponentID(IdxT component_id)
+    {
+      gridkit_component_id_ = component_id;
+      return 0;
+    }
+
+    /**
+     * @brief Link up assigned signal nodes
+     */
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::allocate()
+    {
+      static constexpr auto SREAL = ConstantSignalSourceInternalVariables::SREAL;
+      static constexpr auto SIMAG = ConstantSignalSourceInternalVariables::SIMAG;
+
+      if (signals_.template isAssigned<SREAL>())
+      {
+        signals_.template getSignalNode<SREAL>()->set(&s_real_, &sr_index_);
+      }
+      if (signals_.template isAssigned<SIMAG>())
+      {
+        signals_.template getSignalNode<SIMAG>()->set(&s_imag_, &si_index_);
+      }
+
+      return 0;
+    }
+
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::verify() const
+    {
+      return 0;
+    }
+
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::initialize()
+    {
+      return 0;
+    }
+
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::tagDifferentiable()
+    {
+      return 0;
+    }
+
+    template <class scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::setAbsoluteTolerance(RealT)
+    {
+      return 0;
+    }
+
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::evaluateResidual()
+    {
+      return 0;
+    }
+
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::evaluateJacobian()
+    {
+      return 0;
+    }
+
+  } // namespace PhasorDynamics
+} // namespace GridKit

GridKit/Model/PhasorDynamics/SignalSource/README.md

@@ -0,0 +1,20 @@
+# Constant signal source
+
+This component emits a constant complex value on two output ports (real and
+imaginary).
+
+## Model Parameters
+
+The complex-value parameter is intentionally ambiguous, because it may be
+applied in different contexts (for different input variables).
+
+Symbol      | Units   | Description                     | Note
+------------|---------|---------------------------------| ------
+$Sr$  | unspecified | Real component  |
+$Si$  | unspecified | Imaginary component  | 
+
+## Output ports
+- `sr` ($S_r$)
+- `si` ($S_i$)
+
+Constant parameters are made available to signal nodes.

GridKit/Model/PhasorDynamics/SystemModelData.hpp

@@ -16,6 +16,7 @@
 #include <GridKit/Model/PhasorDynamics/Load/LoadZ/LoadZData.hpp>
 #include <GridKit/Model/PhasorDynamics/Load/LoadZIP/LoadZIPData.hpp>
 #include <GridKit/Model/PhasorDynamics/SignalNode/SignalNodeData.hpp>
+#include <GridKit/Model/PhasorDynamics/SignalSource/ConstantSignalSourceData.hpp>
 #include <GridKit/Model/PhasorDynamics/Stabilizer/IEEEST/IeeestData.hpp>
 #include <GridKit/Model/PhasorDynamics/SynchronousMachine/GENROUwS/GenrouData.hpp>
 #include <GridKit/Model/PhasorDynamics/SynchronousMachine/GENSALwS/GensalData.hpp>
@@ -49,6 +50,7 @@ namespace GridKit
       using GenClassicalDataT       = GenClassicalData<RealT, IdxT>;
       using LoadZDataT              = LoadZData<RealT, IdxT>;
       using LoadZIPDataT            = LoadZIPData<RealT, IdxT>;
+      using ConstantSourceT         = ConstantSignalSourceData<RealT, IdxT>;
       using SignalDataT             = SignalNodeData<RealT, IdxT>;
       using MonitorSinkSpec         = Model::VariableMonitorBase::SinkSpec;
 
@@ -89,20 +91,21 @@ namespace GridKit
       /// - Convert string to enum
       /// - Associate component type to its corresponding enum
       /// - Consolidate components to allow writing to them using the enum as the argument
-      std::vector<BusDataT>                bus;          ///< Buses within the model
-      std::vector<BusToSignalAdapterDataT> adapter;      ///< bus-to-signal adapters within the model
-      std::vector<BranchDataT>             branch;       ///< Branches within the model
-      std::vector<BusFaultDataT>           bus_fault;    ///< Bus faults within the model
-      std::vector<GenrouDataT>             genrou;       ///< GENROU instances within the model
-      std::vector<GensalDataT>             gensal;       ///< GENSAL instances within the model
-      std::vector<GenClassicalDataT>       genclassical; ///< Classical generator instances within the model
-      std::vector<LoadZDataT>              loadz;        ///< LoadZ instances within the model
-      std::vector<LoadZIPDataT>            loadzip;      ///< LoadZIP instances within the model
-      std::vector<Tgov1DataT>              gov;          ///< Governors within the model
-      std::vector<Ieeet1DataT>             exciter;      ///< Exciters within the model
-      std::vector<SexsPtiDataT>            sexspti;      ///< SEXS-PTI exciters within the model
-      std::vector<IeeestDataT>             stabilizer;   ///< Stabilizers within the model
-      std::vector<SignalDataT>             signal;       ///< Signal nodes
+      std::vector<BusDataT>                bus;             ///< Buses within the model
+      std::vector<BusToSignalAdapterDataT> adapter;         ///< bus-to-signal adapters within the model
+      std::vector<BranchDataT>             branch;          ///< Branches within the model
+      std::vector<BusFaultDataT>           bus_fault;       ///< Bus faults within the model
+      std::vector<GenrouDataT>             genrou;          ///< GENROU instances within the model
+      std::vector<GensalDataT>             gensal;          ///< GENSAL instances within the model
+      std::vector<GenClassicalDataT>       genclassical;    ///< Classical generator instances within the model
+      std::vector<LoadZDataT>              loadz;           ///< LoadZ instances within the model
+      std::vector<LoadZIPDataT>            loadzip;         ///< LoadZIP instances within the model
+      std::vector<Tgov1DataT>              gov;             ///< Governors within the model
+      std::vector<Ieeet1DataT>             exciter;         ///< Exciters within the model
+      std::vector<SexsPtiDataT>            sexspti;         ///< SEXS-PTI exciters within the model
+      std::vector<IeeestDataT>             stabilizer;      ///< Stabilizers within the model
+      std::vector<ConstantSourceT>         constant_source; ///< Constant signal sources within the model
+      std::vector<SignalDataT>             signal;          ///< Signal nodes
 
       /// Monitor sink specs
       std::vector<MonitorSinkSpec> monitor_sink;