ConstantSignalSource component and example with BusToSignalAdapter

GridKit/Model/PhasorDynamics/CMakeLists.txt

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

GridKit/Model/PhasorDynamics/ComponentLibrary.hpp

@@ -11,6 +11,7 @@
 #include <GridKit/Model/PhasorDynamics/Load/Load.hpp>
 #include <GridKit/Model/PhasorDynamics/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,71 @@
+#pragma once
+
+#include <GridKit/Model/PhasorDynamics/Component.hpp>
+#include <GridKit/Model/PhasorDynamics/ComponentSignals.hpp>
+
+namespace GridKit
+{
+  namespace PhasorDynamics
+  {
+    template <typename real_type, typename index_type>
+    struct ConstantSignalSourceData;
+
+    enum class ConstantSignalSourceInternalVariables : size_t
+    {
+      SREAL,
+      SIMAG,
+      MAXIMUM,
+    };
+
+    enum class ConstantSignalSourceExternalVariables : size_t
+    {
+      MAXIMUM,
+    };
+
+    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 evaluateResidual() override final;
+      int evaluateJacobian() override final;
+
+      auto getSignals()
+          -> ComponentSignals<ScalarT,
+                              IdxT,
+                              ConstantSignalSourceInternalVariables,
+                              ConstantSignalSourceExternalVariables>&
+      {
+        return signals_;
+      }
+
+    private:
+      ScalarT s_real_;
+      ScalarT s_imag_;
+
+      IdxT sr_index_{INVALID_INDEX<IdxT>};
+      IdxT si_index_{INVALID_INDEX<IdxT>};
+
+      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,100 @@
+
+#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;
+
+    template <typename scalar_type, typename index_type>
+    ConstantSignalSource<scalar_type, index_type>::ConstantSignalSource()
+    {
+      size_ = 0;
+    }
+
+    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()
+    {
+    }
+
+    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));
+      }
+    }
+
+    template <typename scalar_type, typename index_type>
+    int ConstantSignalSource<scalar_type, index_type>::setGridKitComponentID(IdxT component_id)
+    {
+      gridkit_component_id_ = component_id;
+      return 0;
+    }
+
+    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 <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/SystemModelData.hpp

@@ -16,6 +16,7 @@
 #include <GridKit/Model/PhasorDynamics/Load/LoadData.hpp>
 #include <GridKit/Model/PhasorDynamics/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 LoadDataT               = LoadData<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<LoadDataT>               load;         ///< Loads within the model
-      std::vector<LoadZIPDataT>            loadzip;      ///< Loads 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<LoadDataT>               load;            ///< Loads within the model
+      std::vector<LoadZIPDataT>            loadzip;         ///< Loads 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;

GridKit/Model/PhasorDynamics/SystemModelDataJSONParser.hpp

@@ -160,6 +160,12 @@ namespace GridKit
           raw_component.get_to(stabilizer);
           sm.stabilizer.push_back(stabilizer);
         }
+        else if (kind == "ConstantSignalSource")
+        {
+          typename SystemModelData<RealT, IdxT>::ConstantSourceT source;
+          raw_component.get_to(source);
+          sm.constant_source.push_back(source);
+        }
         else if (kind == "BusFault")
         {
           typename SystemModelData<RealT, IdxT>::BusFaultDataT bus_fault;

GridKit/Model/PhasorDynamics/SystemModelImpl.hpp

@@ -351,6 +351,28 @@ namespace GridKit
         addComponent(stabilizer);
       }
 
+      // Add constant signal sources
+      for (const auto& srcdata : data.constant_source)
+      {
+        auto* source = new ConstantSignalSource<ScalarT, IdxT>(srcdata);
+
+        using Ports = ConstantSignalSourcePorts;
+        if (srcdata.ports.contains(Ports::sr))
+        {
+          IdxT           sr    = srcdata.ports.at(Ports::sr);
+          constexpr auto SREAL = ConstantSignalSourceInternalVariables::SREAL;
+          source->getSignals().template assignSignalNode<SREAL>(getSignal(sr));
+        }
+        if (srcdata.ports.contains(Ports::si))
+        {
+          IdxT           si    = srcdata.ports.at(Ports::si);
+          constexpr auto SIMAG = ConstantSignalSourceInternalVariables::SIMAG;
+          source->getSignals().template assignSignalNode<SIMAG>(getSignal(si));
+        }
+
+        addComponent(source);
+      }
+
       // Add faults
       for (const auto& faultdata : data.bus_fault)
       {

examples/PhasorDynamics/Tiny/ThreeBus/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_subdirectory(Basic)
 add_subdirectory(Classical)
+add_subdirectory(ConstantSource)
 add_subdirectory(ZipLoad)

examples/PhasorDynamics/Tiny/ThreeBus/ConstantSource/CMakeLists.txt

@@ -0,0 +1,7 @@
+gridkit_example_add_file(ThreeBusConstantSource.case.json)
+gridkit_example_add_file(ThreeBusConstantSource.solver.json)
+
+add_test(
+  NAME ThreeBusConstantSource_pdsim
+  COMMAND DynamicSimulation ThreeBusConstantSource.solver.json
+  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})