DecouplingIdealTransformer_DP_Ph1.h

// SPDX-FileCopyrightText: 2026 Institute for Automation of Complex Power Systems, EONERC, RWTH Aachen University
// SPDX-License-Identifier: MPL-2.0
 
#pragma once
 
#include <vector>
 
#include "dpsim-models/DP/DP_Ph1_ControlledVoltageSource.h"
#include "dpsim-models/Definitions.h"
#include "dpsim-models/SimNode.h"
#include "dpsim-models/TopologicalNode.h"
#include <dpsim-models/DP/DP_Ph1_ControlledCurrentSource.h>
#include <dpsim-models/DP/DP_Ph1_Resistor.h>
#include <dpsim-models/SimSignalComp.h>
#include <dpsim-models/Task.h>
 
namespace CPS {
namespace Signal {
class DecouplingIdealTransformer_DP_Ph1
    : public SimSignalComp,
      public SharedFactory<DecouplingIdealTransformer_DP_Ph1> {
protected:
  Real mDelay;
  Real mInternalSeriesResistance = 1e-9;
  Real mInternalParallelResistance = 1e9;
 
  std::shared_ptr<DP::SimNode> mNode1, mNode2, mVirtualNode;
  std::shared_ptr<DP::Ph1::Resistor> mRes1, mRes2;
  std::shared_ptr<DP::Ph1::ControlledCurrentSource> mCurrentSrc;
  std::shared_ptr<DP::Ph1::ControlledVoltageSource> mVoltageSrc;
  Attribute<Complex>::Ptr mSrcCurrent, mSrcVoltage;
 
  // Ringbuffers for the values of previous timesteps
  // TODO make these matrix attributes
  std::vector<Complex> mCur1, mVol2;
 
  // Copy of the most recent elements of the ring buffers
  // They are used to perform extrapolation
  std::vector<Complex> mCur1Extrap, mVol2Extrap;
  Complex mCurrent1Extrap0;
 
  UInt mBufIdx = 0;
  UInt mMacroBufIdx = 0;
  UInt mBufSize;
  Real mAlpha;
  CouplingMethod mCouplingMethod;
  UInt mExtrapolationDegree = 0;
  Matrix mVoltageSrcIntfCurr;
 
  // Get an approximate value of the signal in between steps when the delay is not an integer multiple of the step size
  Complex interpolate(std::vector<Complex> &data);
 
  // Estimates the value of the input signal in the next step
  Complex extrapolate(std::vector<Complex> &data);
 
public:
  typedef std::shared_ptr<DecouplingIdealTransformer_DP_Ph1> Ptr;
 
  const Attribute<Complex>::Ptr mSourceVoltageIntfVoltage;
  const Attribute<Complex>::Ptr mSourceVoltageIntfCurrent;
  const Attribute<Complex>::Ptr mSrcCurrentRef;
  const Attribute<Complex>::Ptr mSrcVoltageRef;

  const Attribute<Matrix>::Ptr mStates;
 
  DecouplingIdealTransformer_DP_Ph1(
      String name, Logger::Level logLevel = Logger::Level::info);
 
  void setParameters(SimNode<Complex>::Ptr node1, SimNode<Complex>::Ptr node2,
                     Real delay, Matrix voltageSrcIntfCurr,
                     Complex current1Extrap0,
                     CouplingMethod method = CouplingMethod::DELAY);
  void initialize(Real omega, Real timeStep);
  void step(Real time, Int timeStepCount);
  void postStep();
  Task::List getTasks();
  IdentifiedObject::List getComponents();
  TopologicalNode::Ptr getVirtualNode();
 
  class PreStep : public Task {
  public:
    PreStep(DecouplingIdealTransformer_DP_Ph1 &itm)
        : Task(**itm.mName + ".MnaPreStep"), mITM(itm) {
      mPrevStepDependencies.push_back(mITM.mStates);
      mModifiedAttributes.push_back(mITM.mVoltageSrc->mVoltageRef);
      mModifiedAttributes.push_back(mITM.mCurrentSrc->mCurrentRef);
    }
 
    void execute(Real time, Int timeStepCount);
 
  private:
    DecouplingIdealTransformer_DP_Ph1 &mITM;
  };
 
  class PostStep : public Task {
  public:
    PostStep(DecouplingIdealTransformer_DP_Ph1 &itm)
        : Task(**itm.mName + ".PostStep"), mITM(itm) {
      mAttributeDependencies.push_back(mITM.mVoltageSrc->mIntfVoltage);
      mAttributeDependencies.push_back(mITM.mVoltageSrc->mIntfCurrent);
      mAttributeDependencies.push_back(mITM.mCurrentSrc->mIntfVoltage);
      mAttributeDependencies.push_back(mITM.mCurrentSrc->mIntfCurrent);
      mModifiedAttributes.push_back(mITM.mStates);
    }
 
    void execute(Real time, Int timeStepCount);
 
  private:
    DecouplingIdealTransformer_DP_Ph1 &mITM;
  };
};
} // namespace Signal
} // namespace CPS