DP_Ph3_AvVoltSourceInverterStateSpace.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Institute for Automation of Complex Power Systems, EONERC, RWTH Aachen University
// SPDX-License-Identifier: MPL-2.0
 
#pragma once
 
#include <array>
 
#include <dpsim-models/DP/DP_Ph3_MixedVTypeVariableSSNComp.h>
 
namespace CPS {
namespace DP {
namespace Ph3 {

class AvVoltSourceInverterStateSpace final
    : public MixedVTypeVariableSSNComp,
      public SharedFactory<AvVoltSourceInverterStateSpace> {
private:
  enum StateIndex : Int {
    VcARe = 0,
    VcAIm = 1,
    VcBRe = 2,
    VcBIm = 3,
    VcCRe = 4,
    VcCIm = 5,
    IfARe = 6,
    IfAIm = 7,
    IfBRe = 8,
    IfBIm = 9,
    IfCRe = 10,
    IfCIm = 11,
    Psi = 12,
    PhiPLL = 13,
    PFiltered = 14,
    QFiltered = 15,
    PhiD = 16,
    PhiQ = 17,
    GammaD = 18,
    GammaQ = 19,
    GammaND = 20,
    GammaNQ = 21
  };

  using Complex3 = std::array<Complex, 3>;

  const Bool mEnableNegSeqControl;
 
  static constexpr std::array<Int, 3> mVcReCol = {VcARe, VcBRe, VcCRe};
  static constexpr std::array<Int, 3> mVcImCol = {VcAIm, VcBIm, VcCIm};
  static constexpr std::array<Int, 3> mIfReCol = {IfARe, IfBRe, IfCRe};
  static constexpr std::array<Int, 3> mIfImCol = {IfAIm, IfBIm, IfCIm};
  static constexpr std::array<Int, 3> mUReCol = {0, 2, 4};
  static constexpr std::array<Int, 3> mUImCol = {1, 3, 5};

  static constexpr std::array<Int, 7> mOwnCol = {
      Psi, PFiltered, QFiltered, PhiD, PhiQ, GammaD, GammaQ};
 
  Real mLf = 0.0;
  Real mCf = 0.0;
  Real mRf = 0.0;
  Real mRc = 0.0;
 
  Real mOmegaN = 0.0;
  Real mKpPLL = 0.0;
  Real mKiPLL = 0.0;
 
  Real mOmegaCutoff = 0.0;
  Real mPRef = 0.0;
  Real mQRef = 0.0;
  Real mKpPowerCtrl = 0.0;
  Real mKiPowerCtrl = 0.0;
  Real mKpCurrCtrl = 0.0;
  Real mKiCurrCtrl = 0.0;

  Real mIRefNd = 0.0;
  Real mIRefNq = 0.0;
 
  const Attribute<Real>::Ptr mVcD;
  const Attribute<Real>::Ptr mVcQ;
  const Attribute<Real>::Ptr mIrcD;
  const Attribute<Real>::Ptr mIrcQ;
  const Attribute<Real>::Ptr mPInst;
  const Attribute<Real>::Ptr mQInst;
  const Attribute<Real>::Ptr mOmegaPLL;
  const Attribute<Real>::Ptr mIrcNd;
  const Attribute<Real>::Ptr mIrcNq;

  struct NegSeqTerms {
    Complex ircNDQ{0.0, 0.0};
    Complex vRefNDQ{0.0, 0.0};
    Complex vRefNEnv0{0.0, 0.0};
    Complex3 hIrcN{};
  };

  struct RefSensitivities {
    std::array<Complex, 7> posOwn{};
    Complex3 posVcRe{};
    Complex3 posVcIm{};
    Complex3 posURe{};
    Complex3 posUIm{};
    Complex negPsi{0.0, 0.0};
    Complex negGammaND{0.0, 0.0};
    Complex negGammaNQ{0.0, 0.0};
    Complex3 negVcRe{};
    Complex3 negVcIm{};
    Complex3 negURe{};
    Complex3 negUIm{};
  };

  void buildStateSpaceModel(const Matrix &x, const Matrix &u, Matrix &A,
                            Matrix &B, Matrix &C, Matrix &D, Matrix &E,
                            Matrix &F) const;

  NegSeqTerms computeNegSeqTerms(const Matrix &x, const Complex3 &vc,
                                 const Complex3 &uEnv,
                                 const Complex3 &redistFactor,
                                 const Complex3 &projCoeff,
                                 const Complex &expJPsi) const;

  void buildInductorRows(const Complex3 &redistFactor,
                         const Complex3 &projCoeff,
                         const RefSensitivities &sens, Matrix &A,
                         Matrix &B) const;
 
protected:
  Bool updateComponentParameters() override final;
  void updateLogAttributes(const Matrix &u) const override final;
 
public:
  using SharedFactory<AvVoltSourceInverterStateSpace>::make;

  AvVoltSourceInverterStateSpace(String uid, String name,
                                 Logger::Level logLevel = Logger::Level::off,
                                 Bool enableNegSeqControl = false);
  AvVoltSourceInverterStateSpace(String name,
                                 Logger::Level logLevel = Logger::Level::off,
                                 Bool enableNegSeqControl = false)
      : AvVoltSourceInverterStateSpace(name, name, logLevel,
                                       enableNegSeqControl) {}
 
  void setParameters(Real lf, Real cf, Real rf, Real rc, Real omegaN,
                     Real kpPLL, Real kiPLL, Real omegaCutoff, Real pRef,
                     Real qRef, Real kpPowerCtrl, Real kiPowerCtrl,
                     Real kpCurrCtrl, Real kiCurrCtrl, Real iRefNd = 0.0,
                     Real iRefNq = 0.0);
 
  void initializeFromNodesAndTerminals(Real frequency) override;
};
 
} // namespace Ph3
} // namespace DP
} // namespace CPS